// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Reflection;
using System.Runtime.Loader;
using Moq;

namespace System.Drawing.Design.Tests;

public class ToolboxItemTests
{
    [Fact]
    public void ToolboxItem_Ctor_Default()
    {
        ToolboxItem item = new();
        Assert.Null(item.AssemblyName);
        Assert.Null(item.Bitmap);
        Assert.Null(item.Company);
        Assert.Equal(".NET Component", item.ComponentType);
        Assert.Null(item.DependentAssemblies);
        Assert.Null(item.Description);
        Assert.Empty(item.DisplayName);
        Assert.Empty(item.Filter);
        Assert.Same(item.Filter, item.Filter);
        Assert.False(item.IsTransient);
        Assert.False(item.Locked);
        Assert.Null(item.OriginalBitmap);
        Assert.Empty(item.Properties);
        Assert.Same(item.Properties, item.Properties);
        Assert.False(item.Properties.IsFixedSize);
        Assert.False(item.Properties.IsReadOnly);
        Assert.Empty(item.TypeName);
        Assert.Empty(item.Version);
    }

    public static IEnumerable<object[]> AssemblyName_Set_TestData()
    {
        yield return new object[] { null };
        yield return new object[] { new AssemblyName() };
        yield return new object[] { new AssemblyName(typeof(int).Assembly.FullName) };
    }

    [Theory]
    [MemberData(nameof(AssemblyName_Set_TestData))]
    public void ToolboxItem_AssemblyName_Set_GetReturnsExpected(AssemblyName value)
    {
        ToolboxItem item = new()
        {
            AssemblyName = value
        };
        if (value is null)
        {
            Assert.Null(item.AssemblyName);
            Assert.Null(item.Properties["AssemblyName"]);
            Assert.Empty(item.Version);
        }
        else
        {
            Assert.Equal(value.FullName, item.AssemblyName.FullName);
            Assert.NotSame(value, item.AssemblyName);
            Assert.NotSame(item.AssemblyName, item.AssemblyName);
            Assert.Equal(value.FullName, ((AssemblyName)item.Properties["AssemblyName"]).FullName);
            Assert.NotSame(value, item.Properties["AssemblyName"]);
            Assert.NotSame(item.Properties["AssemblyName"], item.Properties["AssemblyName"]);
            Assert.Equal(value.Version?.ToString() ?? string.Empty, item.Version);
        }

        // Set same.
        item.AssemblyName = value;
        if (value is null)
        {
            Assert.Null(item.AssemblyName);
            Assert.Null(item.Properties["AssemblyName"]);
            Assert.Empty(item.Version);
        }
        else
        {
            Assert.Equal(value.FullName, item.AssemblyName.FullName);
            Assert.NotSame(value, item.AssemblyName);
            Assert.NotSame(item.AssemblyName, item.AssemblyName);
            Assert.Equal(value.FullName, ((AssemblyName)item.Properties["AssemblyName"]).FullName);
            Assert.NotSame(value, item.Properties["AssemblyName"]);
            Assert.NotSame(item.Properties["AssemblyName"], item.Properties["AssemblyName"]);
            Assert.Equal(value.Version?.ToString() ?? string.Empty, item.Version);
        }
    }

    [Fact]
    public void ToolboxItem_AssemblyName_SetWithInvalidPropertyType_ThrowsArgumentException()
    {
        ToolboxItem item = new();
        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("AssemblyName", new object()));
    }

    public static IEnumerable<object[]> Bitmap_Set_TestData()
    {
        yield return new object[] { null };
        yield return new object[] { new Bitmap(10, 10) };
    }

    [Theory]
    [MemberData(nameof(Bitmap_Set_TestData))]
    public void ToolboxItem_Bitmap_Set_GetReturnsExpected(Bitmap value)
    {
        ToolboxItem item = new()
        {
            Bitmap = value
        };
        Assert.Same(value, item.Bitmap);
        Assert.Same(value, item.Properties["Bitmap"]);

        // Set same.
        item.Bitmap = value;
        Assert.Same(value, item.Bitmap);
        Assert.Same(value, item.Properties["Bitmap"]);
    }

    [Fact]
    public void ToolboxItem_Bitmap_SetWithInvalidPropertyType_ThrowsArgumentException()
    {
        ToolboxItem item = new();
        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("Bitmap", new object()));
    }

    [Theory]
    [NormalizedStringData]
    public void ToolboxItem_Company_Set_GetReturnsExpected(string value, string expected)
    {
        ToolboxItem item = new()
        {
            Company = value
        };
        Assert.Equal(expected, item.Company);
        Assert.Equal(expected, item.Properties["Company"]);

        // Set same.
        item.Company = value;
        Assert.Equal(expected, item.Company);
        Assert.Equal(expected, item.Properties["Company"]);
    }

    [Fact]
    public void ToolboxItem_Company_SetWithInvalidPropertyType_ThrowsArgumentException()
    {
        ToolboxItem item = new();
        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("Company", new object()));
    }

    public static IEnumerable<object[]> DependentAssemblies_Set_TestData()
    {
        yield return new object[] { null };
        yield return new object[] { Array.Empty<AssemblyName>() };
        yield return new object[] { new AssemblyName[] { null } };
        yield return new object[] { new AssemblyName[] { new() } };
    }

    [Theory]
    [MemberData(nameof(DependentAssemblies_Set_TestData))]
    public void ToolboxItem_DependentAssemblies_Set_GetReturnsExpected(AssemblyName[] value)
    {
        ToolboxItem item = new()
        {
            DependentAssemblies = value
        };
        if (value is null)
        {
            Assert.Null(item.DependentAssemblies);
            Assert.Null(item.Properties["DependentAssemblies"]);
        }
        else
        {
            Assert.Equal(value, item.DependentAssemblies);
            Assert.NotSame(value, item.DependentAssemblies);
            Assert.Equal(value, item.Properties["DependentAssemblies"]);
            Assert.NotSame(value, item.Properties["DependentAssemblies"]);
        }

        // Set same.
        item.DependentAssemblies = value;
        if (value is null)
        {
            Assert.Null(item.DependentAssemblies);
            Assert.Null(item.Properties["DependentAssemblies"]);
        }
        else
        {
            Assert.Equal(value, item.DependentAssemblies);
            Assert.NotSame(value, item.DependentAssemblies);
            Assert.Equal(value, item.Properties["DependentAssemblies"]);
            Assert.NotSame(value, item.Properties["DependentAssemblies"]);
        }
    }

    [Fact]
    public void ToolboxItem_DependentAssemblies_SetWithInvalidPropertyType_GetThrowsArgumentException()
    {
        ToolboxItem item = new();
        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("DependentAssemblies", new object()));
    }

    [Theory]
    [NormalizedStringData]
    public void ToolboxItem_Description_Set_GetReturnsExpected(string value, string expected)
    {
        ToolboxItem item = new()
        {
            Description = value
        };
        Assert.Equal(expected, item.Description);
        Assert.Equal(expected, item.Properties["Description"]);

        // Set same.
        item.Description = value;
        Assert.Equal(expected, item.Description);
        Assert.Equal(expected, item.Properties["Description"]);
    }

    [Fact]
    public void ToolboxItem_Description_SetWithInvalidPropertyType_ThrowsArgumentException()
    {
        ToolboxItem item = new();
        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("Description", new object()));
    }

    [Theory]
    [NormalizedStringData]
    public void ToolboxItem_DisplayName_Set_GetReturnsExpected(string value, string expected)
    {
        ToolboxItem item = new()
        {
            DisplayName = value
        };
        Assert.Equal(expected, item.DisplayName);
        Assert.Equal(expected, item.Properties["DisplayName"]);

        // Set same.
        item.DisplayName = value;
        Assert.Equal(expected, item.DisplayName);
        Assert.Equal(expected, item.Properties["DisplayName"]);
    }

    [Fact]
    public void ToolboxItem_DisplayName_SetWithInvalidPropertyType_ThrowsArgumentException()
    {
        ToolboxItem item = new();
        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("DisplayName", new object()));
    }

    public static IEnumerable<object[]> Filter_Set_TestData()
    {
        yield return new object[] { null, Array.Empty<object>() };
        yield return new object[] { Array.Empty<object>(), Array.Empty<object>() };
        yield return new object[] { new object[] { null }, Array.Empty<object>() };
        yield return new object[] { new object[] { new(), new ToolboxItemFilterAttribute("filterString") }, new object[] { new ToolboxItemFilterAttribute("filterString") } };
    }

    [Theory]
    [MemberData(nameof(Filter_Set_TestData))]
    public void ToolboxItem_Filter_Set_GetReturnsExpected(ICollection value, ICollection expected)
    {
        ToolboxItem item = new()
        {
            Filter = value
        };
        Assert.Equal(expected, item.Filter);
        Assert.Equal(expected, item.Properties["Filter"]);

        // Set same.
        item.Filter = value;
        Assert.Equal(expected, item.Filter);
        Assert.Equal(expected, item.Properties["Filter"]);
    }

    [Fact]
    public void ToolboxItem_Filter_SetWithInvalidPropertyType_GetThrowsArgumentException()
    {
        ToolboxItem item = new();
        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("Filter", new object()));
    }

    [Theory]
    [BoolData]
    public void ToolboxItem_IsTransient_Set_GetReturnsExpected(bool value)
    {
        ToolboxItem item = new()
        {
            IsTransient = value
        };
        Assert.Equal(value, item.IsTransient);
        Assert.Equal(value, item.Properties["IsTransient"]);

        // Set same.
        item.IsTransient = value;
        Assert.Equal(value, item.IsTransient);
        Assert.Equal(value, item.Properties["IsTransient"]);
    }

    [Fact]
    public void ToolboxItem_IsTransient_SetWithNullPropertyType_GetThrowsArgumentNullException()
    {
        ToolboxItem item = new();
        Assert.Throws<ArgumentNullException>("value", () => item.Properties.Add("IsTransient", null));
    }

    [Fact]
    public void ToolboxItem_IsTransient_SetWithInvalidPropertyType_GetThrowsArgumentException()
    {
        ToolboxItem item = new();
        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("IsTransient", new object()));
    }

    [Theory]
    [MemberData(nameof(Bitmap_Set_TestData))]
    public void ToolboxItem_OriginalBitmap_Set_GetReturnsExpected(Bitmap value)
    {
        ToolboxItem item = new()
        {
            OriginalBitmap = value
        };
        Assert.Same(value, item.OriginalBitmap);
        Assert.Same(value, item.Properties["OriginalBitmap"]);

        // Set same.
        item.OriginalBitmap = value;
        Assert.Same(value, item.OriginalBitmap);
        Assert.Same(value, item.Properties["OriginalBitmap"]);
    }

    [Fact]
    public void ToolboxItem_OriginalBitmap_SetWithInvalidPropertyType_ThrowsArgumentException()
    {
        ToolboxItem item = new();
        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("OriginalBitmap", new object()));
    }

    [Theory]
    [NormalizedStringData]
    public void ToolboxItem_TypeName_Set_GetReturnsExpected(string value, string expected)
    {
        ToolboxItem item = new()
        {
            TypeName = value
        };
        Assert.Equal(expected, item.TypeName);
        Assert.Equal(expected, item.Properties["TypeName"]);

        // Set same.
        item.TypeName = value;
        Assert.Equal(expected, item.TypeName);
        Assert.Equal(expected, item.Properties["TypeName"]);
    }

    [Fact]
    public void ToolboxItem_TypeName_SetWithInvalidPropertyType_ThrowsArgumentException()
    {
        ToolboxItem item = new();
        Assert.Throws<ArgumentException>("value", () => item.Properties.Add("TypeName", new object()));
    }

    [Fact]
    public void ToolboxItem_CreateComponents_InvokeWithoutHost_ReturnsExpected()
    {
        ToolboxItem item = new()
        {
            AssemblyName = typeof(Component).Assembly.GetName(true),
            TypeName = "System.ComponentModel.Component"
        };
        int creatingCallCount = 0;
        int createdCallCount = 0;
        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Null(e.DesignerHost);
            creatingCallCount++;
        };
        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.IsType<Component>(Assert.Single(e.Components));
            createdCallCount++;
        };
        item.ComponentsCreating += creatingHandler;
        item.ComponentsCreated += createdHandler;

        // With handler.
        Assert.IsType<Component>(Assert.Single(item.CreateComponents()));
        Assert.Equal(1, creatingCallCount);
        Assert.Equal(1, createdCallCount);

        Assert.IsType<Component>(Assert.Single(item.CreateComponents(null)));
        Assert.Equal(2, creatingCallCount);
        Assert.Equal(2, createdCallCount);

        // Remove handler.
        item.ComponentsCreating -= creatingHandler;
        item.ComponentsCreated -= createdHandler;

        Assert.IsType<Component>(Assert.Single(item.CreateComponents(null)));
        Assert.Equal(2, creatingCallCount);
        Assert.Equal(2, createdCallCount);
    }

    public static IEnumerable<object[]> CreateComponents_InvokeWithHostWithNonIComponentInitializerDesigner_TestData()
    {
        Mock<IDesigner> mockDesigner = new(MockBehavior.Strict);
        mockDesigner.Setup(d => d.Dispose());

        yield return new object[] { new Component(), null };
        yield return new object[] { new Component(), mockDesigner.Object };

        yield return new object[] { null, null };
        yield return new object[] { null, mockDesigner.Object };
    }

    [Theory]
    [MemberData(nameof(CreateComponents_InvokeWithHostWithNonIComponentInitializerDesigner_TestData))]
    public void ToolboxItem_CreateComponents_InvokeWithHostWithNonIComponentInitializerDesigner_ReturnsExpected(Component component, IDesigner designer)
    {
        ToolboxItem item = new()
        {
            TypeName = "typeName"
        };
        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
        mockDesignerHost
            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
            .Returns(new CustomTypeResolutionService());
        mockDesignerHost
            .Setup(h => h.CreateComponent(typeof(bool)))
            .Returns(component);
        mockDesignerHost
            .Setup(h => h.GetDesigner(component))
            .Returns(designer);

        int creatingCallCount = 0;
        int createdCallCount = 0;
        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Same(mockDesignerHost.Object, e.DesignerHost);
            creatingCallCount++;
        };
        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Same(component, Assert.Single(e.Components));
            createdCallCount++;
        };
        item.ComponentsCreating += creatingHandler;
        item.ComponentsCreated += createdHandler;

        // With handler.
        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object)));
        Assert.Equal(1, creatingCallCount);
        Assert.Equal(1, createdCallCount);

        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object, null)));
        Assert.Equal(2, creatingCallCount);
        Assert.Equal(2, createdCallCount);

        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object, new Hashtable())));
        Assert.Equal(3, creatingCallCount);
        Assert.Equal(3, createdCallCount);

        // Remove handler.
        item.ComponentsCreating -= creatingHandler;
        item.ComponentsCreated -= createdHandler;

        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object)));
        Assert.Equal(3, creatingCallCount);
        Assert.Equal(3, createdCallCount);
    }

    [Fact]
    public void ToolboxItem_CreateComponents_InvokeWithHostWithIComponentInitializerDesigner_ReturnsExpected()
    {
        using Component component = new();
        ToolboxItem item = new()
        {
            TypeName = "typeName"
        };
        Mock<IDesigner> mockDesigner = new(MockBehavior.Strict);
        mockDesigner.Setup(d => d.Dispose());
        Mock<IComponentInitializer> mockComponentInitializer = mockDesigner.As<IComponentInitializer>();
        mockComponentInitializer
            .Setup(i => i.InitializeNewComponent(null));
        mockComponentInitializer
            .Setup(i => i.InitializeNewComponent(new Hashtable()));

        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
        mockDesignerHost
            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
            .Returns(new CustomTypeResolutionService());
        mockDesignerHost
            .Setup(h => h.CreateComponent(typeof(bool)))
            .Returns(component);
        mockDesignerHost
            .Setup(h => h.GetDesigner(component))
            .Returns(mockDesigner.Object);

        int creatingCallCount = 0;
        int createdCallCount = 0;
        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Same(mockDesignerHost.Object, e.DesignerHost);
            creatingCallCount++;
        };
        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Same(component, Assert.Single(e.Components));
            createdCallCount++;
        };
        item.ComponentsCreating += creatingHandler;
        item.ComponentsCreated += createdHandler;

        // With handler.
        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object)));
        Assert.Equal(1, creatingCallCount);
        Assert.Equal(1, createdCallCount);

        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object, null)));
        Assert.Equal(2, creatingCallCount);
        Assert.Equal(2, createdCallCount);

        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object, new Hashtable())));
        Assert.Equal(3, creatingCallCount);
        Assert.Equal(3, createdCallCount);

        // Remove handler.
        item.ComponentsCreating -= creatingHandler;
        item.ComponentsCreated -= createdHandler;

        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object)));
        Assert.Equal(3, creatingCallCount);
        Assert.Equal(3, createdCallCount);
    }

    [Fact]
    public void ToolboxItem_CreateComponents_InvokeWithHostWithThrowingIComponentInitializerDesigner_ReturnsExpected()
    {
        using Component component = new();
        ToolboxItem item = new()
        {
            TypeName = "typeName"
        };
        Mock<IDesigner> mockDesigner = new(MockBehavior.Strict);
        mockDesigner.Setup(d => d.Dispose());
        Mock<IComponentInitializer> mockComponentInitializer = mockDesigner.As<IComponentInitializer>();
        mockComponentInitializer
            .Setup(i => i.InitializeNewComponent(null))
            .Throws(new InvalidOperationException());
        mockComponentInitializer
            .Setup(i => i.InitializeNewComponent(new Hashtable()))
            .Throws(new InvalidOperationException());

        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
        mockDesignerHost
            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
            .Returns(new CustomTypeResolutionService());
        mockDesignerHost
            .Setup(h => h.CreateComponent(typeof(bool)))
            .Returns(component);
        mockDesignerHost
            .Setup(h => h.GetDesigner(component))
            .Returns(mockDesigner.Object);
        mockDesignerHost
            .Setup(h => h.DestroyComponent(component));

        int creatingCallCount = 0;
        int createdCallCount = 0;
        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Same(mockDesignerHost.Object, e.DesignerHost);
            creatingCallCount++;
        };
        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Same(component, Assert.Single(e.Components));
            createdCallCount++;
        };
        item.ComponentsCreating += creatingHandler;
        item.ComponentsCreated += createdHandler;

        // With handler.
        Assert.Throws<InvalidOperationException>(() => item.CreateComponents(mockDesignerHost.Object));
        Assert.Equal(1, creatingCallCount);
        Assert.Equal(0, createdCallCount);

        Assert.Throws<InvalidOperationException>(() => item.CreateComponents(mockDesignerHost.Object, null));
        Assert.Equal(2, creatingCallCount);
        Assert.Equal(0, createdCallCount);

        Assert.Throws<InvalidOperationException>(() => item.CreateComponents(mockDesignerHost.Object, new Hashtable()));
        Assert.Equal(3, creatingCallCount);
        Assert.Equal(0, createdCallCount);

        // Remove handler.
        item.ComponentsCreating -= creatingHandler;
        item.ComponentsCreated -= createdHandler;

        Assert.Throws<InvalidOperationException>(() => item.CreateComponents(mockDesignerHost.Object));
        Assert.Equal(3, creatingCallCount);
        Assert.Equal(0, createdCallCount);
    }

    [Fact]
    public void ToolboxItem_CreateComponents_InvokeWithNullComponentsCoreWithHost_ReturnsExpected()
    {
        NullComponentsToolboxItem item = new()
        {
            TypeName = "typeName"
        };
        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
        mockDesignerHost
            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
            .Returns(new CustomTypeResolutionService());
        mockDesignerHost
            .Setup(h => h.CreateComponent(typeof(bool)))
            .Returns(new Component());

        int creatingCallCount = 0;
        int createdCallCount = 0;
        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Same(mockDesignerHost.Object, e.DesignerHost);
            creatingCallCount++;
        };
        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Null(e.Components);
            createdCallCount++;
        };
        item.ComponentsCreating += creatingHandler;
        item.ComponentsCreated += createdHandler;

        // With handler.
        Assert.Null(item.CreateComponents(mockDesignerHost.Object));
        Assert.Equal(1, creatingCallCount);
        Assert.Equal(0, createdCallCount);

        Assert.Null(item.CreateComponents(mockDesignerHost.Object, null));
        Assert.Equal(2, creatingCallCount);
        Assert.Equal(0, createdCallCount);

        Assert.Null(item.CreateComponents(mockDesignerHost.Object, new Hashtable()));
        Assert.Equal(3, creatingCallCount);
        Assert.Equal(0, createdCallCount);

        // Remove handler.
        item.ComponentsCreating -= creatingHandler;
        item.ComponentsCreated -= createdHandler;

        Assert.Null(item.CreateComponents(mockDesignerHost.Object));
        Assert.Equal(3, creatingCallCount);
        Assert.Equal(0, createdCallCount);
    }

    [Theory]
    [InlineData("")]
    [InlineData("NoSuchType")]
    [InlineData("System.Int32")]
    public void ToolboxItem_CreateComponents_InvokeInvalidType_ReturnsEmpty(string typeName)
    {
        ToolboxItem item = new()
        {
            TypeName = typeName
        };
        int creatingCallCount = 0;
        int createdCallCount = 0;
        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Null(e.DesignerHost);
            creatingCallCount++;
        };
        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Null(e.Components);
            createdCallCount++;
        };
        item.ComponentsCreating += creatingHandler;
        item.ComponentsCreated += createdHandler;

        Assert.Empty(item.CreateComponents());
        Assert.Equal(1, creatingCallCount);
        Assert.Equal(0, createdCallCount);
    }

    [Fact]
    public void ToolboxItem_CreateComponentsCore_InvokeWithoutHost_ReturnsExpected()
    {
        SubToolboxItem item = new()
        {
            AssemblyName = typeof(Component).Assembly.GetName(true),
            TypeName = "System.ComponentModel.Component"
        };
        int creatingCallCount = 0;
        int createdCallCount = 0;
        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Null(e.DesignerHost);
            creatingCallCount++;
        };
        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.IsType<Component>(Assert.Single(e.Components));
            createdCallCount++;
        };
        item.ComponentsCreating += creatingHandler;
        item.ComponentsCreated += createdHandler;

        // With handler.
        Assert.IsType<Component>(Assert.Single(item.CreateComponentsCore(null)));
        Assert.Equal(0, creatingCallCount);
        Assert.Equal(0, createdCallCount);

        // Remove handler.
        item.ComponentsCreating -= creatingHandler;
        item.ComponentsCreated -= createdHandler;

        Assert.IsType<Component>(Assert.Single(item.CreateComponentsCore(null)));
        Assert.Equal(0, creatingCallCount);
        Assert.Equal(0, createdCallCount);
    }

    [Theory]
    [MemberData(nameof(CreateComponents_InvokeWithHostWithNonIComponentInitializerDesigner_TestData))]
    public void ToolboxItem_CreateComponentsCore_InvokeWithHostWithNonIComponentInitializerDesigner_ReturnsExpected(Component component, IDesigner designer)
    {
        SubToolboxItem item = new()
        {
            TypeName = "typeName"
        };
        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
        mockDesignerHost
            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
            .Returns(new CustomTypeResolutionService());
        mockDesignerHost
            .Setup(h => h.CreateComponent(typeof(bool)))
            .Returns(component);
        mockDesignerHost
            .Setup(h => h.GetDesigner(component))
            .Returns(designer);

        int creatingCallCount = 0;
        int createdCallCount = 0;
        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Same(mockDesignerHost.Object, e.DesignerHost);
            creatingCallCount++;
        };
        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Same(component, Assert.Single(e.Components));
            createdCallCount++;
        };
        item.ComponentsCreating += creatingHandler;
        item.ComponentsCreated += createdHandler;

        // With handler.
        Assert.Same(component, Assert.Single(item.CreateComponentsCore(mockDesignerHost.Object)));
        Assert.Equal(0, creatingCallCount);
        Assert.Equal(0, createdCallCount);

        Assert.Same(component, Assert.Single(item.CreateComponentsCore(mockDesignerHost.Object, null)));
        Assert.Equal(0, creatingCallCount);
        Assert.Equal(0, createdCallCount);

        Assert.Same(component, Assert.Single(item.CreateComponentsCore(mockDesignerHost.Object, new Hashtable())));
        Assert.Equal(0, creatingCallCount);
        Assert.Equal(0, createdCallCount);

        // Remove handler.
        item.ComponentsCreating -= creatingHandler;
        item.ComponentsCreated -= createdHandler;

        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object)));
        Assert.Equal(0, creatingCallCount);
        Assert.Equal(0, createdCallCount);
    }

    [Fact]
    public void ToolboxItem_CreateComponentsCore_InvokeWithHostWithIComponentInitializerDesigner_ReturnsExpected()
    {
        using Component component = new();
        SubToolboxItem item = new()
        {
            TypeName = "typeName"
        };
        Mock<IDesigner> mockDesigner = new(MockBehavior.Strict);
        mockDesigner.Setup(d => d.Dispose());
        Mock<IComponentInitializer> mockComponentInitializer = mockDesigner.As<IComponentInitializer>();
        mockComponentInitializer
            .Setup(i => i.InitializeNewComponent(null));
        mockComponentInitializer
            .Setup(i => i.InitializeNewComponent(new Hashtable()));

        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
        mockDesignerHost
            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
            .Returns(new CustomTypeResolutionService());
        mockDesignerHost
            .Setup(h => h.CreateComponent(typeof(bool)))
            .Returns(component);
        mockDesignerHost
            .Setup(h => h.GetDesigner(component))
            .Returns(mockDesigner.Object);

        int creatingCallCount = 0;
        int createdCallCount = 0;
        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Same(mockDesignerHost.Object, e.DesignerHost);
            creatingCallCount++;
        };
        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Same(component, Assert.Single(e.Components));
            createdCallCount++;
        };
        item.ComponentsCreating += creatingHandler;
        item.ComponentsCreated += createdHandler;

        // With handler.
        Assert.Same(component, Assert.Single(item.CreateComponentsCore(mockDesignerHost.Object)));
        Assert.Equal(0, creatingCallCount);
        Assert.Equal(0, createdCallCount);

        Assert.Same(component, Assert.Single(item.CreateComponentsCore(mockDesignerHost.Object, null)));
        Assert.Equal(0, creatingCallCount);
        Assert.Equal(0, createdCallCount);

        Assert.Same(component, Assert.Single(item.CreateComponentsCore(mockDesignerHost.Object, new Hashtable())));
        Assert.Equal(0, creatingCallCount);
        Assert.Equal(0, createdCallCount);

        // Remove handler.
        item.ComponentsCreating -= creatingHandler;
        item.ComponentsCreated -= createdHandler;

        Assert.Same(component, Assert.Single(item.CreateComponents(mockDesignerHost.Object)));
        Assert.Equal(0, creatingCallCount);
        Assert.Equal(0, createdCallCount);
    }

    [Fact]
    public void ToolboxItem_CreateComponentsCore_InvokeWithHostWithThrowingIComponentInitializerDesigner_ReturnsExpected()
    {
        using Component component = new();
        SubToolboxItem item = new()
        {
            TypeName = "typeName"
        };
        Mock<IDesigner> mockDesigner = new(MockBehavior.Strict);
        mockDesigner.Setup(d => d.Dispose());
        Mock<IComponentInitializer> mockComponentInitializer = mockDesigner.As<IComponentInitializer>();
        mockComponentInitializer
            .Setup(i => i.InitializeNewComponent(null))
            .Throws(new InvalidOperationException());
        mockComponentInitializer
            .Setup(i => i.InitializeNewComponent(new Hashtable()))
            .Throws(new InvalidOperationException());

        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
        mockDesignerHost
            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
            .Returns(new CustomTypeResolutionService());
        mockDesignerHost
            .Setup(h => h.CreateComponent(typeof(bool)))
            .Returns(component);
        mockDesignerHost
            .Setup(h => h.GetDesigner(component))
            .Returns(mockDesigner.Object);
        mockDesignerHost
            .Setup(h => h.DestroyComponent(component));

        int creatingCallCount = 0;
        int createdCallCount = 0;
        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Same(mockDesignerHost.Object, e.DesignerHost);
            creatingCallCount++;
        };
        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Same(component, Assert.Single(e.Components));
            createdCallCount++;
        };
        item.ComponentsCreating += creatingHandler;
        item.ComponentsCreated += createdHandler;

        // With handler.
        Assert.Same(component, Assert.Single(item.CreateComponentsCore(mockDesignerHost.Object)));
        Assert.Equal(0, creatingCallCount);
        Assert.Equal(0, createdCallCount);

        Assert.Throws<InvalidOperationException>(() => item.CreateComponentsCore(mockDesignerHost.Object, null));
        Assert.Equal(0, creatingCallCount);
        Assert.Equal(0, createdCallCount);

        Assert.Throws<InvalidOperationException>(() => item.CreateComponentsCore(mockDesignerHost.Object, new Hashtable()));
        Assert.Equal(0, creatingCallCount);
        Assert.Equal(0, createdCallCount);

        // Remove handler.
        item.ComponentsCreating -= creatingHandler;
        item.ComponentsCreated -= createdHandler;

        Assert.Same(component, Assert.Single(item.CreateComponentsCore(mockDesignerHost.Object)));
        Assert.Equal(0, creatingCallCount);
        Assert.Equal(0, createdCallCount);
    }

    [Theory]
    [InlineData("")]
    [InlineData("NoSuchType")]
    [InlineData("System.Int32")]
    public void ToolboxItem_CreateComponentsCore_InvokeInvalidType_ReturnsEmpty(string typeName)
    {
        SubToolboxItem item = new()
        {
            TypeName = typeName
        };
        int creatingCallCount = 0;
        int createdCallCount = 0;
        ToolboxComponentsCreatingEventHandler creatingHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Null(e.DesignerHost);
            creatingCallCount++;
        };
        ToolboxComponentsCreatedEventHandler createdHandler = (sender, e) =>
        {
            Assert.Same(item, sender);
            Assert.Null(e.Components);
            createdCallCount++;
        };
        item.ComponentsCreating += creatingHandler;
        item.ComponentsCreated += createdHandler;

        Assert.Empty(item.CreateComponentsCore(null));
        Assert.Equal(0, creatingCallCount);
        Assert.Equal(0, createdCallCount);
    }

    [Fact]
    public void ToolboxItem_CheckUnlocked_NotLocked_Nop()
    {
        SubToolboxItem item = new();
        item.CheckUnlocked();
        item.CheckUnlocked();
    }

    [Fact]
    public void ToolboxItem_CheckUnlocked_Locked_ThrowsInvalidOperationException()
    {
        SubToolboxItem item = new();
        item.Lock();
        Assert.Throws<InvalidOperationException>(item.CheckUnlocked);
    }

    public static IEnumerable<object[]> Equals_TestData()
    {
        ToolboxItem item = new();
        yield return new object[] { item, item, true };
        yield return new object[] { item, new ToolboxItem(), true };
        yield return new object[] { item, new SubToolboxItem(), false };

        yield return new object[]
        {
            item,
            new ToolboxItem
            {
                Company = "Company",
                DependentAssemblies = [null],
                Description = "Description",
                Filter = new ToolboxItemFilterAttribute[] { new("Filter") },
                IsTransient = true
            },
            true
        };

        yield return new object[]
        {
            new ToolboxItem { TypeName = "TypeName" },
            new ToolboxItem { TypeName = "TypeName" },
            true
        };
        yield return new object[]
        {
            new ToolboxItem { TypeName = "TypeName" },
            new ToolboxItem { TypeName = "typename" },
            false
        };
        yield return new object[]
        {
            new ToolboxItem { TypeName = "TypeName" },
            new ToolboxItem(),
            false
        };
        yield return new object[]
        {
            new ToolboxItem(),
            new ToolboxItem { TypeName = "TypeName" },
            false
        };
        yield return new object[]
        {
            new NoValidationToolboxItem { TypeName = null },
            new NoValidationToolboxItem { TypeName = null },
            true
        };
        yield return new object[]
        {
            new NoValidationToolboxItem { TypeName = null },
            new NoValidationToolboxItem { TypeName = "TypeName" },
            false
        };
        yield return new object[]
        {
            new NoValidationToolboxItem { TypeName = "TypeName" },
            new NoValidationToolboxItem { TypeName = null },
            false
        };

        yield return new object[]
        {
            new ToolboxItem { DisplayName = "DisplayName" },
            new ToolboxItem { DisplayName = "DisplayName" },
            true
        };
        yield return new object[]
        {
            new ToolboxItem { DisplayName = "DisplayName" },
            new ToolboxItem { DisplayName = "displayname" },
            false
        };
        yield return new object[]
        {
            new ToolboxItem { DisplayName = "DisplayName" },
            new ToolboxItem(),
            false
        };
        yield return new object[]
        {
            new ToolboxItem(),
            new ToolboxItem { DisplayName = "DisplayName" },
            false
        };
        yield return new object[]
        {
            new NoValidationToolboxItem { DisplayName = null },
            new NoValidationToolboxItem { DisplayName = null },
            true
        };
        yield return new object[]
        {
            new NoValidationToolboxItem { DisplayName = null },
            new NoValidationToolboxItem { DisplayName = "TypeName" },
            false
        };
        yield return new object[]
        {
            new NoValidationToolboxItem { DisplayName = "TypeName" },
            new NoValidationToolboxItem { DisplayName = null },
            false
        };

        yield return new object[]
        {
            new ToolboxItem { AssemblyName = new AssemblyName("Name") },
            new ToolboxItem { AssemblyName = new AssemblyName("Name") },
            true
        };
        yield return new object[]
        {
            new ToolboxItem { AssemblyName = new AssemblyName("Name") },
            new ToolboxItem { AssemblyName = new AssemblyName("name") },
            false
        };
        yield return new object[]
        {
            new ToolboxItem(),
            new ToolboxItem { AssemblyName = new AssemblyName("Name") },
            false
        };
        yield return new object[]
        {
            new ToolboxItem { AssemblyName = new AssemblyName("Name") },
            new ToolboxItem(),
            false
        };

        yield return new object[] { new ToolboxItem(), new(), false };
        yield return new object[] { new ToolboxItem(), null, false };
    }

    [Theory]
    [MemberData(nameof(Equals_TestData))]
    public void ToolboxItem_Equals_Invoke_ReturnsExpected(ToolboxItem item, object other, bool expected)
    {
        Assert.Equal(expected, item.Equals(other));
    }

    public static IEnumerable<object[]> FilterPropertyValue_TestData()
    {
        object o = new();
        yield return new object[] { "AssemblyName", null, null, true };
        yield return new object[] { "AssemblyName", new AssemblyName("Name"), new AssemblyName("Name"), false };
        yield return new object[] { "AssemblyName", o, o, true };
        yield return new object[] { "assemblyName", new AssemblyName("Name"), new AssemblyName("Name"), true };

        yield return new object[] { "DisplayName", null, string.Empty, false };
        yield return new object[] { "DisplayName", "value", "value", true };
        yield return new object[] { "DisplayName", o, o, true };
        yield return new object[] { "displayname", null, null, true };

        yield return new object[] { "TypeName", null, string.Empty, false };
        yield return new object[] { "TypeName", "value", "value", true };
        yield return new object[] { "TypeName", o, o, true };
        yield return new object[] { "typename", null, null, true };

        yield return new object[] { "Filter", null, Array.Empty<ToolboxItemFilterAttribute>(), false };
        yield return new object[] { "Filter", Array.Empty<ToolboxItemFilterAttribute>(), Array.Empty<ToolboxItemFilterAttribute>(), true };
        yield return new object[] { "Filter", o, o, true };
        yield return new object[] { "filter", null, null, true };

        yield return new object[] { "IsTransient", null, false, false };
        yield return new object[] { "IsTransient", true, true, true };
        yield return new object[] { "IsTransient", o, o, true };
        yield return new object[] { "istransient", null, null, true };

        yield return new object[] { "NoSuchProperty", null, null, true };
        yield return new object[] { "NoSuchProperty", "value", "value", true };
        yield return new object[] { "NoSuchProperty", o, o, true };
    }

    [Theory]
    [MemberData(nameof(FilterPropertyValue_TestData))]
    public void ToolboxItem_FilterPropertyValue_Invoke_ReturnsExpected(string propertyName, object value, object expected, bool same)
    {
        SubToolboxItem item = new();
        object actual = item.FilterPropertyValue(propertyName, value);
        if (expected is AssemblyName expectedName)
        {
            Assert.Equal(expectedName.FullName, Assert.IsType<AssemblyName>(actual).FullName);
        }
        else
        {
            Assert.Equal(expected, actual);
        }

        Assert.Equal(same, ReferenceEquals(value, actual));
    }

    public static IEnumerable<object[]> GetHashCode_TestData()
    {
        yield return new object[] { new ToolboxItem() };
        yield return new object[] { new ToolboxItem { TypeName = "TypeName", DisplayName = "DisplayName" } };
        yield return new object[] { new NoValidationToolboxItem { TypeName = null, DisplayName = null } };
    }

    [Theory]
    [MemberData(nameof(GetHashCode_TestData))]
    public void ToolboxItem_GetHashCode_Invoke_ReturnsExpected(ToolboxItem item)
    {
        Assert.Equal(item.GetHashCode(), item.GetHashCode());
    }

    public static IEnumerable<object[]> GetType_TestData()
    {
        Mock<IDesignerHost> nullServiceDesignerHost = new(MockBehavior.Strict);
        nullServiceDesignerHost
            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
            .Returns(null);
        foreach (object host in new object[] { null, nullServiceDesignerHost.Object })
        {
            yield return new object[] { null, null, "System.Int32", false, typeof(int) };
            yield return new object[] { null, new AssemblyName("NoSuchAssembly"), "System.Int32", false, typeof(int) };
            yield return new object[] { null, new AssemblyName(typeof(int).Assembly.FullName), "System.Int32", false, typeof(int) };
            yield return new object[] { null, new AssemblyName(typeof(ToolboxItem).Assembly.FullName), "System.Int32", false, typeof(int) };
            yield return new object[] { null, new AssemblyName(typeof(int).Assembly.FullName), "System.Drawing.Design.Tests.ToolboxItemTests", false, null };
            yield return new object[] { null, new AssemblyName(typeof(ToolboxItemTests).Assembly.FullName), "System.Drawing.Design.Tests.ToolboxItemTests", false, typeof(ToolboxItemTests) };
            yield return new object[] { null, new AssemblyName(typeof(ToolboxItemTests).Assembly.FullName), "System.Drawing.Design.Tests.toolboxitemtests", false, null };
            yield return new object[] { null, new AssemblyName(typeof(ToolboxItemTests).Assembly.FullName), "NoSuchType", false, null };
            yield return new object[] { null, null, string.Empty, false, null };

#pragma warning disable SYSLIB0044 // Type or member is obsolete
            AssemblyName validNameWithCodeBase = new(typeof(int).Assembly.FullName)
            {
                CodeBase = "System.Windows.Forms.Design.Tests.dll"
            };
            yield return new object[] { null, validNameWithCodeBase, "System.Drawing.Design.Tests.ToolboxItemTests", false, null };

            AssemblyName invalidNameWithCodeBase = new("NoSuchAssembly")
            {
                CodeBase = "System.Windows.Forms.Design.Tests.dll"
            };
            yield return new object[] { null, invalidNameWithCodeBase, "System.Drawing.Design.Tests.ToolboxItemTests", false, typeof(ToolboxItemTests) };

            AssemblyName invalidNameWithInvalidCodeBase = new("NoSuchAssembly")
            {
                CodeBase = "AlsoNoSuchAssembly"
            };
            yield return new object[] { null, invalidNameWithInvalidCodeBase, "System.Drawing.Design.Tests.ToolboxItemTests", false, null };

            AssemblyLoadContext.Default.Resolving += (context, name) =>
            {
                if (name.Name == "ThrowBadImageFormatException")
                {
                    throw new BadImageFormatException();
                }
                else if (name.Name == "ThrowIOException")
                {
                    throw new IOException();
                }

                return null;
            };
            yield return new object[] { null, new AssemblyName("ThrowBadImageFormatException"), "System.Int32", false, typeof(int) };
            yield return new object[] { null, new AssemblyName("ThrowIOException"), "System.Int32", false, typeof(int) };

            AssemblyName badImageFormatExceptionCodeBase = new("NoSuchAssembly")
            {
                CodeBase = "ThrowBadImageFormatException"
            };
            yield return new object[] { null, badImageFormatExceptionCodeBase, "System.Int32", false, typeof(int) };

            AssemblyName ioFormatExceptionCodeBase = new("NoSuchAssembly")
            {
                CodeBase = "ThrowIOException"
            };
#pragma warning restore SYSLIB0044
            yield return new object[] { null, ioFormatExceptionCodeBase, "System.Int32", false, typeof(int) };
        }

        Mock<IDesignerHost> invalidServiceDesignerHost = new(MockBehavior.Strict);
        invalidServiceDesignerHost
            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
            .Returns(new object());
        yield return new object[] { invalidServiceDesignerHost.Object, new AssemblyName(typeof(int).Assembly.FullName), "System.Int32", false, typeof(int) };

        foreach (bool reference in new bool[] { true, false })
        {
            Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
            mockDesignerHost
                .Setup(h => h.GetService(typeof(ITypeResolutionService)))
                .Returns(new CustomTypeResolutionService());
            yield return new object[] { mockDesignerHost.Object, null, "typeName", reference, typeof(bool) };
            yield return new object[] { mockDesignerHost.Object, null, string.Empty, false, null };
            yield return new object[] { mockDesignerHost.Object, new AssemblyName(), "typeName", reference, typeof(bool) };
            yield return new object[] { mockDesignerHost.Object, new AssemblyName(typeof(int).Assembly.FullName), "System.Int32", reference, typeof(int) };
            yield return new object[] { mockDesignerHost.Object, new AssemblyName(typeof(int).Assembly.FullName), "System.Drawing.Design.Tests.ToolboxItemTests", reference, typeof(ToolboxItemTests) };
            yield return new object[] { mockDesignerHost.Object, new AssemblyName(typeof(int).Assembly.FullName), "System.Drawing.Design.Tests.toolboxitemtests", reference, null };
            yield return new object[] { mockDesignerHost.Object, new AssemblyName(typeof(int).Assembly.FullName), "NoSuchType", reference, null };
        }
    }

    [Theory]
    [MemberData(nameof(GetType_TestData))]
    public void ToolboxItem_GetType_InvokeWithoutTypeNameAssemblyName_ReturnsExpected(IDesignerHost host, AssemblyName assemblyName, string typeName, bool reference, Type expected)
    {
        if (reference)
        {
            return;
        }

        ToolboxItem item = new()
        {
            AssemblyName = assemblyName,
            TypeName = typeName
        };
        Assert.Equal(expected, item.GetType(host));
    }

    [Theory]
    [MemberData(nameof(GetType_TestData))]
    public void ToolboxItem_GetType_InvokeWithTypeNameAssemblyName_ReturnsExpected(IDesignerHost host, AssemblyName assemblyName, string typeName, bool reference, Type expected)
    {
        SubToolboxItem item = new();
        Assert.Equal(expected, item.GetType(host, assemblyName, typeName, reference));
    }

    [Fact]
    public void ToolboxItem_GetType_NullTypeName_ThrowsArgumentNullException()
    {
        SubToolboxItem item = new();
        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
        mockDesignerHost
            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
            .Returns(null);
        Assert.Throws<ArgumentNullException>("typeName", () => item.GetType(mockDesignerHost.Object, null, null, false));
        Assert.Throws<ArgumentNullException>("typeName", () => item.GetType(null, null, null, false));
    }

    [Fact]
    public void ToolboxItem_GetType_EmptyAssemblyName_ThrowsArgumentException()
    {
        SubToolboxItem item = new();
        Mock<IDesignerHost> mockDesignerHost = new(MockBehavior.Strict);
        mockDesignerHost
            .Setup(h => h.GetService(typeof(ITypeResolutionService)))
            .Returns(null);
        Assert.Throws<ArgumentException>(() => item.GetType(mockDesignerHost.Object, new AssemblyName(), "typeName", false));
        Assert.Throws<ArgumentException>(() => item.GetType(null, new AssemblyName(), "typeName", false));
    }

    public static IEnumerable<object[]> Initialize_TypeWithAttributes_TestData()
    {
        yield return new object[] { typeof(ClassWithValidAttributes), new Size(16, 16) };
        yield return new object[] { typeof(ClassWithStretchedWidthImage), new Size(24, 16) };
        yield return new object[] { typeof(ClassWithStretchedHeightImage), new Size(16, 24) };
        yield return new object[] { typeof(ClassWithInvalidImage), new Size(16, 16) };
    }

    [Theory]
    [MemberData(nameof(Initialize_TypeWithAttributes_TestData))]
    public void ToolboxItem_Initialize_TypeWithAttributes_Success(Type type, Size expectedOriginalBitmapSize)
    {
        using Bitmap bitmap = new(10, 10);
        using Bitmap originalBitmap = new(10, 10);

        var filter = new ToolboxItemFilterAttribute[] { new("Filter") };
        ToolboxItem item = new()
        {
            AssemblyName = new AssemblyName("AssemblyName"),
            Bitmap = bitmap,
            Company = "Company",
            Description = "Description",
            DependentAssemblies = new AssemblyName[2],
            DisplayName = "DisplayName",
            Filter = filter,
            OriginalBitmap = originalBitmap
        };
        item.Initialize(type);
        if (expectedOriginalBitmapSize == new Size(10, 10))
        {
            Assert.NotEqual(bitmap, item.Bitmap);
            Assert.Same(item.Bitmap, item.Bitmap);
        }
        else
        {
            Assert.Equal(new Size(16, 16), item.Bitmap.Size);
        }

        Assert.Equal("Microsoft Corporation", item.Company);
        Assert.Equal("Description", item.Description);
        Assert.Equal(type.Assembly.FullName, item.AssemblyName.FullName);
        Assert.Equal(new string[] { type.Assembly.FullName }, item.DependentAssemblies.Select(a => a.FullName));
        Assert.Equal(type.Name, item.DisplayName);
        Assert.Equal(new string[] { type.Name, "Filter", "System.Drawing.Design.Tests.ToolboxItemTests+" + type.Name }, item.Filter.Cast<ToolboxItemFilterAttribute>().Select(a => a.FilterString).OrderBy(f => f));
        Assert.Equal(expectedOriginalBitmapSize, item.OriginalBitmap.Size);

        Assert.Equal("Microsoft Corporation", item.Company);
        Assert.Equal("Description", item.Description);
        Assert.Equal(type.Assembly.FullName, item.AssemblyName.FullName);
        Assert.Equal(new string[] { type.Assembly.FullName }, item.DependentAssemblies.Select(a => a.FullName));
        Assert.Equal(type.Name, item.DisplayName);
        Assert.Equal(new string[] { type.Name, "Filter", "System.Drawing.Design.Tests.ToolboxItemTests+" + type.Name }, item.Filter.Cast<ToolboxItemFilterAttribute>().Select(a => a.FilterString).OrderBy(f => f));
        Assert.Equal(expectedOriginalBitmapSize, item.OriginalBitmap.Size);
    }

    [Fact]
    public void ToolboxItem_Initialize_ObjectType_Success()
    {
        using Bitmap bitmap = new(10, 10);
        using Bitmap originalBitmap = new(10, 10);
        var filter = new ToolboxItemFilterAttribute[] { new("Filter") };
        ToolboxItem item = new()
        {
            AssemblyName = new AssemblyName("AssemblyName"),
            Bitmap = bitmap,
            Company = "Company",
            Description = "Description",
            DependentAssemblies = new AssemblyName[2],
            DisplayName = "DisplayName",
            Filter = filter,
            OriginalBitmap = originalBitmap
        };
        item.Initialize(typeof(object));
        Assert.NotEqual(bitmap, item.Bitmap);
        Assert.Same(item.Bitmap, item.Bitmap);
        Assert.Equal("Microsoft Corporation", item.Company);
        Assert.Empty(item.Description);
        Assert.Equal(typeof(object).Assembly.FullName, item.AssemblyName.FullName);
        Assert.Equal(new string[] { typeof(object).Assembly.FullName }, item.DependentAssemblies.Select(a => a.FullName));
        Assert.Equal("Object", item.DisplayName);
        Assert.Equal(new string[] { "System.Object" }, item.Filter.Cast<ToolboxItemFilterAttribute>().Select(a => a.FilterString));
        Assert.Same(item.OriginalBitmap, item.OriginalBitmap);
    }

    [Fact]
    public void ToolboxItem_Initialize_NullType_Nop()
    {
        using Bitmap bitmap = new(10, 10);
        using Bitmap originalBitmap = new(10, 10);
        var filter = new ToolboxItemFilterAttribute[] { new("Filter") };
        ToolboxItem item = new()
        {
            AssemblyName = new AssemblyName("AssemblyName"),
            Bitmap = bitmap,
            Company = "Company",
            Description = "Description",
            DependentAssemblies = new AssemblyName[2],
            DisplayName = "DisplayName",
            Filter = filter,
            OriginalBitmap = originalBitmap
        };
        item.Initialize(null);
        Assert.Equal("AssemblyName", item.AssemblyName.FullName);
        Assert.Same(bitmap, item.Bitmap);
        Assert.Equal("Company", item.Company);
        Assert.Equal("Description", item.Description);
        Assert.Equal(new AssemblyName[2], item.DependentAssemblies);
        Assert.Equal("DisplayName", item.DisplayName);
        Assert.Equal(filter, item.Filter);
        Assert.Same(originalBitmap, item.OriginalBitmap);
    }

    [Theory]
    [InlineData(null)]
    [InlineData(typeof(int))]
    public void ToolboxItem_Initialize_Locked_ThrowsInvalidOperationException(Type type)
    {
        ToolboxItem item = new();
        item.Lock();
        Assert.Throws<InvalidOperationException>(() => item.Initialize(type));
    }

    [Fact]
    public void ToolboxItem_Lock_Invoke_Success()
    {
        ToolboxItem item = new();
        item.Lock();
        Assert.True(item.Locked);
        Assert.True(item.Properties.IsFixedSize);
        Assert.True(item.Properties.IsReadOnly);

        // Lock again.
        item.Lock();
        Assert.True(item.Locked);
        Assert.True(item.Properties.IsFixedSize);
        Assert.True(item.Properties.IsReadOnly);
    }

    [Fact]
    public void ToolboxItem_OnComponentsCreated_Invoke_Success()
    {
        SubToolboxItem item = new();

        // No handler.
        item.OnComponentsCreated(null);

        // Handler.
        int callCount = 0;
        ToolboxComponentsCreatedEventHandler handler = (sender, e) =>
        {
            Assert.Equal(item, sender);
            Assert.Null(e);
            callCount++;
        };

        item.ComponentsCreated += handler;
        item.OnComponentsCreated(null);
        Assert.Equal(1, callCount);

        // Should not call if the handler is removed.
        item.ComponentsCreated -= handler;
        item.OnComponentsCreated(null);
        Assert.Equal(1, callCount);
    }

    [Fact]
    public void ToolboxItem_OnComponentsCreating_Invoke_Success()
    {
        SubToolboxItem item = new();

        // No handler.
        item.OnComponentsCreating(null);

        // Handler.
        int callCount = 0;
        ToolboxComponentsCreatingEventHandler handler = (sender, e) =>
        {
            Assert.Equal(item, sender);
            Assert.Null(e);
            callCount++;
        };

        item.ComponentsCreating += handler;
        item.OnComponentsCreating(null);
        Assert.Equal(1, callCount);

        // Should not call if the handler is removed.
        item.ComponentsCreating -= handler;
        item.OnComponentsCreating(null);
        Assert.Equal(1, callCount);
    }

    public static IEnumerable<object[]> ToString_TestData()
    {
        yield return new object[] { new ToolboxItem(), string.Empty };
        yield return new object[] { new ToolboxItem { DisplayName = "DisplayName" }, "DisplayName" };
        yield return new object[] { new NoValidationToolboxItem { DisplayName = null }, string.Empty };
    }

    [Theory]
    [MemberData(nameof(ToString_TestData))]
    public void ToolboxItem_ToString_Invoke_ReturnsExpected(ToolboxItem item, string expected)
    {
        Assert.Equal(expected, item.ToString());
    }

    public static IEnumerable<object[]> ValidatePropertyValue_TestData()
    {
        AssemblyName name = new();
        yield return new object[] { "AssemblyName", null, null };
        yield return new object[] { "AssemblyName", name, name };

        Bitmap bitmap = new(10, 10);
        yield return new object[] { "Bitmap", null, null };
        yield return new object[] { "Bitmap", bitmap, bitmap };

        Bitmap originalBitmap = new(10, 10);
        yield return new object[] { "OriginalBitmap", null, null };
        yield return new object[] { "OriginalBitmap", originalBitmap, originalBitmap };

        yield return new object[] { "Company", null, string.Empty };
        yield return new object[] { "Company", "value", "value" };

        yield return new object[] { "Description", null, string.Empty };
        yield return new object[] { "Description", "value", "value" };

        yield return new object[] { "DisplayName", null, string.Empty };
        yield return new object[] { "DisplayName", "value", "value" };

        yield return new object[] { "TypeName", null, string.Empty };
        yield return new object[] { "TypeName", "value", "value" };

        ToolboxItemFilterAttribute filter = new("filter");
        yield return new object[] { "Filter", null, Array.Empty<ToolboxItemFilterAttribute>() };
        yield return new object[] { "Filter", Array.Empty<ToolboxItemFilterAttribute>(), Array.Empty<ToolboxItemFilterAttribute>() };
        yield return new object[] { "Filter", new object[] { null, "value", filter, filter }, new ToolboxItemFilterAttribute[] { filter, filter } };

        yield return new object[] { "NoSuchProperty", null, null };
        yield return new object[] { "NoSuchProperty", 1, 1 };

        yield return new object[] { "istransient", null, null };
        yield return new object[] { "istransient", 1, 1 };
    }

    [Theory]
    [MemberData(nameof(ValidatePropertyValue_TestData))]
    public void ToolboxItem_ValidatePropertyValue_ValueAllowed_ReturnsExpected(string propertyName, object value, object expected)
    {
        SubToolboxItem item = new();
        Assert.Equal(expected, item.ValidatePropertyValue(propertyName, value));
    }

    [Theory]
    [InlineData("IsTransient")]
    public void ToolboxItem_ValidatePropertyValue_NullValueDisallowed_ThrowsArgumentNullException(string propertyName)
    {
        SubToolboxItem item = new();
        Assert.Throws<ArgumentNullException>("value", () => item.ValidatePropertyValue(propertyName, null));
    }

    [Theory]
    [InlineData("AssemblyName")]
    [InlineData("Bitmap")]
    [InlineData("OriginalBitmap")]
    [InlineData("Company")]
    [InlineData("Description")]
    [InlineData("DisplayName")]
    [InlineData("TypeName")]
    [InlineData("Filter")]
    [InlineData("DependentAssemblies")]
    public void ToolboxItem_ValidatePropertyValue_InvalidValue_ThrowsArgumentException(string propertyName)
    {
        SubToolboxItem item = new();
        Assert.Throws<ArgumentException>("value", () => item.ValidatePropertyValue(propertyName, new object()));
    }

    [Theory]
    [InlineData(null, null)]
    [InlineData("propertyName", typeof(int))]
    public void ToolboxItem_ValidatePropertyType_NullDisallowed_ThrowsArgumentNullException(string propertyName, Type expectedType)
    {
        SubToolboxItem item = new();
        Assert.Throws<ArgumentNullException>("value", () => item.ValidatePropertyType(propertyName, null, expectedType, allowNull: false));
    }

    [Theory]
    [InlineData(null, null)]
    [InlineData("propertyName", typeof(int))]
    public void ToolboxItem_ValidatePropertyType_NullAllowed_Nop(string propertyName, Type expectedType)
    {
        SubToolboxItem item = new();
        item.ValidatePropertyType(propertyName, null, expectedType, allowNull: true);
    }

    [Theory]
    [InlineData(null, false)]
    [InlineData("propertyName", true)]
    public void ToolboxItem_ValidatePropertyType_ValidType_Nop(string propertyName, bool allowNull)
    {
        SubToolboxItem item = new();
        item.ValidatePropertyType(propertyName, 1, typeof(int), allowNull);
    }

    [Theory]
    [InlineData(null, false)]
    [InlineData("propertyName", true)]
    public void ToolboxItem_ValidatePropertyType_InvalidType_ThrowsArgumentException(string propertyName, bool allowNull)
    {
        SubToolboxItem item = new();
        Assert.Throws<ArgumentException>("value", () => item.ValidatePropertyType(propertyName, new object(), typeof(int), allowNull));
    }

    private class SubToolboxItem : ToolboxItem
    {
        public new void CheckUnlocked() => base.CheckUnlocked();

        public new IComponent[] CreateComponentsCore(IDesignerHost host)
        {
            return base.CreateComponentsCore(host);
        }

        public new IComponent[] CreateComponentsCore(IDesignerHost host, IDictionary defaultValues)
        {
            return base.CreateComponentsCore(host, defaultValues);
        }

        public new object FilterPropertyValue(string propertyName, object value)
        {
            return base.FilterPropertyValue(propertyName, value);
        }

        public new Type GetType(IDesignerHost host, AssemblyName assemblyName, string typeName, bool reference)
        {
            return base.GetType(host, assemblyName, typeName, reference);
        }

        public new void OnComponentsCreated(ToolboxComponentsCreatedEventArgs args)
        {
            base.OnComponentsCreated(args);
        }

        public new void OnComponentsCreating(ToolboxComponentsCreatingEventArgs args)
        {
            base.OnComponentsCreating(args);
        }

        public new object ValidatePropertyValue(string propertyName, object value)
        {
            return base.ValidatePropertyValue(propertyName, value);
        }

        public new void ValidatePropertyType(string propertyName, object value, Type expectedType, bool allowNull)
        {
            base.ValidatePropertyType(propertyName, value, expectedType, allowNull);
        }
    }

    private class CustomTypeResolutionService : ITypeResolutionService
    {
        public Assembly GetAssemblyResult { get; set; }

        public Assembly GetAssembly(AssemblyName name) => GetAssemblyResult;

        public Assembly GetAssembly(AssemblyName name, bool throwOnError)
        {
            throw new NotImplementedException();
        }

        public string GetPathOfAssembly(AssemblyName name)
        {
            throw new NotImplementedException();
        }

        public Type GetType(string name)
        {
            if (name == "typeName")
            {
                return typeof(bool);
            }

            return Type.GetType(name);
        }

        public Type GetType(string name, bool throwOnError)
        {
            throw new NotImplementedException();
        }

        public Type GetType(string name, bool throwOnError, bool ignoreCase)
        {
            throw new NotImplementedException();
        }

        public List<AssemblyName> ReferenceAssemblies { get; } = [];

        public void ReferenceAssembly(AssemblyName name)
        {
            ReferenceAssemblies.Add(name);
        }
    }

    private class NoValidationToolboxItem : ToolboxItem
    {
        protected override object FilterPropertyValue(string propertyName, object value)
        {
            // Don't normalize.
            return value;
        }

        protected override object ValidatePropertyValue(string propertyName, object value)
        {
            // Don't normalize.
            return value;
        }
    }

    private class NullComponentsToolboxItem : ToolboxItem
    {
        protected override IComponent[] CreateComponentsCore(IDesignerHost host)
        {
            return null;
        }
    }

    [Description("Description")]
    [ToolboxBitmap(typeof(ToolboxItemTests), "16x16.bmp")]
    [ToolboxItemFilter("System.Drawing.Design.Tests.ToolboxItemTests+ClassWithValidAttributes")]
    [ToolboxItemFilter("ClassWithValidAttributes")]
    [ToolboxItemFilter("Filter")]
    private class ClassWithValidAttributes
    {
    }

    [Description("Description")]
    [ToolboxBitmap(typeof(ToolboxItemTests), "24x16.bmp")]
    [ToolboxItemFilter("System.Drawing.Design.Tests.ToolboxItemTests+ClassWithStretchedWidthImage")]
    [ToolboxItemFilter("ClassWithStretchedWidthImage")]
    [ToolboxItemFilter("Filter")]
    private class ClassWithStretchedWidthImage
    {
    }

    [Description("Description")]
    [ToolboxBitmap(typeof(ToolboxItemTests), "16x24.bmp")]
    [ToolboxItemFilter("System.Drawing.Design.Tests.ToolboxItemTests+ClassWithStretchedHeightImage")]
    [ToolboxItemFilter("ClassWithStretchedHeightImage")]
    [ToolboxItemFilter("Filter")]
    private class ClassWithStretchedHeightImage
    {
    }

    [Description("Description")]
    [ToolboxBitmap("NoSuchImage")]
    [ToolboxItemFilter("System.Drawing.Design.Tests.ToolboxItemTests+ClassWithInvalidImage")]
    [ToolboxItemFilter("ClassWithInvalidImage")]
    [ToolboxItemFilter("Filter")]
    private class ClassWithInvalidImage
    {
    }
}
