// Copyright (c) Microsoft Corporation. All rights reserved.

// Licensed under the MIT license.

using System;

using System.Collections.Generic;

using System.Diagnostics.CodeAnalysis;

using System.Linq;

using System.Reflection;

using Microsoft.ClearScript.Util;

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace Microsoft.ClearScript.Test

{

[TestClass]

[SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable", Justification = "Test classes use TestCleanupAttribute for deterministic teardown.")]

public class HostTypeCollectionTest : ClearScriptTest

{

#region test methods

// ReSharper disable InconsistentNaming

[TestMethod, TestCategory("HostTypeCollection")]

public void HostTypeCollection_SingleAssembly()

{

Test(null, new[] { "mscorlib" }, null, (first, second) => first == second);

}

[TestMethod, TestCategory("HostTypeCollection")]

public void HostTypeCollection_MultiAssembly()

{

Test(null, new[] { "mscorlib", "System", "System.Core" }, null, (first, second) => first.FullName == second.FullName);

}

[TestMethod, TestCategory("HostTypeCollection")]

public void HostTypeCollection_SingleAssembly_Filtered()

{

Test(null, new[] { "mscorlib" }, ReflectionFilter, (first, second) => first == second);

}

[TestMethod, TestCategory("HostTypeCollection")]

public void HostTypeCollection_MultiAssembly_Filtered()

{

Test(null, new[] { "mscorlib", "System", "System.Core" }, ReflectionFilter, (first, second) => first.FullName == second.FullName);

}

// ReSharper restore InconsistentNaming

#endregion

#region miscellaneous

private static readonly Predicate<Type> defaultFilter = _ => true;

private static bool ReflectionFilter(Type type)

{

return (type != typeof(Type)) && !type.FullName.StartsWith("System.Reflection.", StringComparison.Ordinal);

}

internal static void Test(HostTypeCollection typeCollection, string[] assemblyNames, Predicate<Type> filter, Func<Type, Type, bool> comparer)

{

typeCollection = typeCollection ?? new HostTypeCollection(filter, assemblyNames);

var allNodes = GetLeafNodes(typeCollection).OrderBy(hostType => hostType.Type.GetLocator()).ToArray();

var visitedNodes = new SortedDictionary<string, HostType>();

foreach (var type in GetImportableTypes(assemblyNames, filter))

{

var currentType = type;

var locator = currentType.GetLocator();

var segments = locator.Split('.');

var hostType = (HostType)segments.Aggregate((object)typeCollection, (node, segment) => ((PropertyBag)node)[segment]);

Assert.IsTrue(hostType.Types.All(testType => testType.GetLocator() == locator));

Assert.AreEqual(1, hostType.Types.Count(testType => comparer(testType, currentType)));

visitedNodes[locator] = hostType;

}

Assert.IsTrue(allNodes.SequenceEqual(visitedNodes.Values));

if (filter is not null)

{

Assert.IsTrue(allNodes.All(hostType => hostType.Types.All(type => filter(type))));

}

}

private static IEnumerable<Type> GetImportableTypes(string[] assemblyNames, Predicate<Type> filter)

{

var assemblies = assemblyNames.Select(assemblyName => Assembly.Load(AssemblyTable.GetFullAssemblyName(assemblyName)));

var activeFilter = filter ?? defaultFilter;

return assemblies.SelectMany(assembly => assembly.GetAllTypes().Where(type => type.IsImportable(null) && activeFilter(type)));

}

private static IEnumerable<HostType> GetLeafNodes(PropertyBag container)

{

foreach (var childNode in container.Values)

{

var childContainer = childNode as PropertyBag;

if (childContainer is null)

{

yield return (HostType)childNode;

}

else

{

foreach (var leafNode in GetLeafNodes(childContainer))

{

yield return leafNode;

}

}

}

}

#endregion

}

}