src/Compilers/Test/Utilities/CSharp/EmitMetadataTestBase.cs - main - githubmirror/roslyn

src/Compilers/Test/Utilities/CSharp/EmitMetadataTestBase.cs
169 строк6 KB
Youssef Victor
Remove unused private members (#61064)
12 июн 2022, 21:22
12 июн 2022, 21:22a528fe2
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

#nullable disable

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Reflection.Metadata;
using System.Xml.Linq;
using Microsoft.CodeAnalysis.CSharp.Symbols;
using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Roslyn.Utilities;
using Xunit;

namespace Microsoft.CodeAnalysis.CSharp.UnitTests
{
    public abstract class EmitMetadataTestBase : CSharpTestBase
    {
        internal static XElement DumpTypeInfo(ModuleSymbol moduleSymbol)
        {
            return LoadChildNamespace(moduleSymbol.GlobalNamespace);
        }

        internal static XElement LoadChildNamespace(NamespaceSymbol n)
        {
            XElement elem = new XElement((n.Name.Length == 0 ? "Global" : n.Name));

            var childrenTypes = n.GetTypeMembers().OrderBy((t) => t, new NameAndArityComparer());

            elem.Add(from t in childrenTypes select LoadChildType(t));

            var childrenNS = n.GetMembers().
                                OfType<NamespaceSymbol>().
                                OrderBy(child => child.Name, StringComparer.OrdinalIgnoreCase);

            elem.Add(from c in childrenNS select LoadChildNamespace(c));

            return elem;
        }

        private static XElement LoadChildType(NamedTypeSymbol t)
        {
            XElement elem = new XElement("type");

            elem.Add(new XAttribute("name", t.Name));

            if (t.Arity > 0)
            {
                string typeParams = string.Empty;

                foreach (var param in t.TypeParameters)
                {
                    if (typeParams.Length > 0)
                    {
                        typeParams += ",";
                    }

                    typeParams += param.Name;
                }

                elem.Add(new XAttribute("Of", typeParams));
            }

            if ((object)t.BaseType() != null)
            {
                elem.Add(new XAttribute("base", t.BaseType().ToTestDisplayString()));
            }

            var fields = t.GetMembers().Where(m => m.Kind == SymbolKind.Field).OrderBy(f => f.Name).Cast<FieldSymbol>();

            elem.Add(from f in fields select LoadField(f));

            var childrenTypes = t.GetTypeMembers().OrderBy(c => c, new NameAndArityComparer());

            elem.Add(from c in childrenTypes select LoadChildType(c));

            return elem;
        }

        private static XElement LoadField(FieldSymbol f)
        {
            XElement elem = new XElement("field");

            elem.Add(new XAttribute("name", f.Name));
            elem.Add(new XAttribute("type", f.Type.ToTestDisplayString()));

            return elem;
        }

        #region DeclSecurityTable Validation
        /// <summary>
        /// Validate the contents of the DeclSecurity metadata table.
        /// </summary>
        internal static void ValidateDeclSecurity(ModuleSymbol module, params DeclSecurityEntry[] expectedEntries)
        {
            var metadataReader = module.GetMetadata().MetadataReader;
            var actualEntries = new List<DeclSecurityEntry>(expectedEntries.Length);

            int i = 0;
            foreach (var actualHandle in metadataReader.DeclarativeSecurityAttributes)
            {
                var actual = metadataReader.GetDeclarativeSecurityAttribute(actualHandle);

                var actualPermissionSetBytes = metadataReader.GetBlobBytes(actual.PermissionSet);
                var actualPermissionSet = new string(actualPermissionSetBytes.Select(b => (char)b).ToArray());
                string actualParentName;
                SymbolKind actualParentKind;
                GetAttributeParentNameAndKind(metadataReader, actual.Parent, out actualParentName, out actualParentKind);

                actualEntries.Add(new DeclSecurityEntry()
                {
                    ActionFlags = actual.Action,
                    ParentNameOpt = actualParentName,
                    PermissionSet = actualPermissionSet,
                    ParentKind = actualParentKind
                });

                i++;
            }

            AssertEx.SetEqual(expectedEntries, actualEntries, itemInspector: entry => $@"
{{
    ActionFlags = {entry.ActionFlags},
    ParentNameOpt = {entry.ParentNameOpt},
    PermissionSet = {entry.PermissionSet},
    ParentKind = {entry.ParentKind}
}}");
        }

        private static void GetAttributeParentNameAndKind(MetadataReader metadataReader, EntityHandle token, out string name, out SymbolKind kind)
        {
            switch (token.Kind)
            {
                case HandleKind.AssemblyDefinition:
                    name = null;
                    kind = SymbolKind.Assembly;
                    return;

                case HandleKind.TypeDefinition:
                    name = metadataReader.GetString(metadataReader.GetTypeDefinition((TypeDefinitionHandle)token).Name);
                    kind = SymbolKind.NamedType;
                    return;

                case HandleKind.MethodDefinition:
                    name = metadataReader.GetString(metadataReader.GetMethodDefinition((MethodDefinitionHandle)token).Name);
                    kind = SymbolKind.Method;
                    return;

                default:
                    throw TestExceptionUtilities.UnexpectedValue(token.Kind);
            }
        }

        internal struct DeclSecurityEntry
        {
            public DeclarativeSecurityAction ActionFlags;
            public SymbolKind ParentKind;
            public string ParentNameOpt;
            public string PermissionSet;
        }

        #endregion
    }
}