// 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.Throws<InvalidOperationException>(() => designer.Component);
        Assert.Same(InheritanceAttribute.Default, designer.InheritanceAttribute);
        Assert.Same(designer.InheritanceAttribute, designer.InheritanceAttribute);
        Assert.False(designer.Inherited);
        Assert.Throws<InvalidOperationException>(() => 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 = 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 = 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(), 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() };
        }
    }
 
    [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, 2, 4 };
        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() };
    }
 
    [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() };
    }
 
    [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.Throws<InvalidOperationException>(() => designer.Component);
        mockComponent.Verify(c => c.Dispose(), Times.Never());
 
        // Dispose again.
        designer.Dispose();
        Assert.Throws<InvalidOperationException>(() => 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() };
        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.Throws<InvalidOperationException>(() => designer.Component);
 
        // Dispose again.
        designer.Dispose();
        Assert.Throws<InvalidOperationException>(() => designer.Component);
    }
 
    [Fact]
    public void ComponentDesigner_Dispose_InvokeWithoutComponent_Throws()
    {
        using ComponentDesigner designer = new();
        designer.Dispose();
        Assert.Throws<InvalidOperationException>(() => designer.Component);
 
        // Dispose again.
        designer.Dispose();
        Assert.Throws<InvalidOperationException>(() => 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);
        if (disposing)
        {
            Assert.Throws<InvalidOperationException>(() => designer.Component);
        }
        else
        {
            Assert.Same(mockComponent.Object, designer.Component);
        }
 
        mockComponent.Verify(c => c.Dispose(), Times.Never());
 
        // Dispose again.
        designer.Dispose(disposing);
        if (disposing)
        {
            Assert.Throws<InvalidOperationException>(() => designer.Component);
        }
        else
        {
            Assert.Same(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(), 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);
        if (disposing)
        {
            Assert.Throws<InvalidOperationException>(() => designer.Component);
        }
        else
        {
            Assert.Same(component, designer.Component);
        }
 
        // Dispose again.
        designer.Dispose(disposing);
        if (disposing)
        {
            Assert.Throws<InvalidOperationException>(() => designer.Component);
        }
        else
        {
            Assert.Same(component, designer.Component);
        }
    }
 
    [Theory]
    [BoolData]
    public void ComponentDesigner_Dispose_InvokeBoolWithoutComponent_Success(bool disposing)
    {
        using SubComponentDesigner designer = new();
        designer.Dispose(disposing);
        Assert.Throws<InvalidOperationException>(() => designer.Component);
 
        // Dispose again.
        designer.Dispose(disposing);
        Assert.Throws<InvalidOperationException>(() => 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(), "NoSuchStringValue" }, 1, null };
            yield return new object[] { property, new object[] { null, new(), "NoSuchStringValue" }, 1, string.Empty };
            yield return new object[] { property, new object[] { null, new(), "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(), 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() } };
    }
 
    [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() };
    }
 
    [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() };
    }
 
    [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() };
    }
 
    [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);
    }
 
    [Fact]
    public void ComponentDesigner_Uninitialized_Component_Throws()
    {
        using ComponentDesigner designer = new();
        Assert.Throws<InvalidOperationException>(() => designer.Component);
    }
 
    [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(), new() };
 
        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() };
        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 = 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 = 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_Throws(IDictionary properties)
    {
        using SubComponentDesigner designer = new();
        Assert.Throws<InvalidOperationException>(() => 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(), new() };
    }
 
    [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() })
        {
            yield return new object[] { componentChangeService, null, null, null };
            yield return new object[] { componentChangeService, TypeDescriptor.GetProperties(typeof(CustomComponent))[0], new(), new() };
        }
    }
 
    [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() })
        {
            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 = 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 = 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();
        using Button button = new();
        designer.Initialize(button);
        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 readonly InheritanceAttribute _inheritanceAttribute;
 
        public CustomInheritanceAttributeComponentDesigner(InheritanceAttribute inheritanceAttribute) : base()
        {
            _inheritanceAttribute = inheritanceAttribute;
        }
 
        protected override InheritanceAttribute InheritanceAttribute => InheritanceAttribute1;
 
        public new bool Inherited => base.Inherited;
 
        public InheritanceAttribute InheritanceAttribute1 => _inheritanceAttribute;
 
        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(Value))]
    private class StringDefaultPropertyComponent : Component
    {
        public string Value { get; set; }
    }
 
    [DefaultProperty(nameof(Value))]
    private class IntDefaultPropertyComponent : Component
    {
        public int Value { get; set; }
    }
 
    [DefaultEvent(nameof(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; }
    }
}