src/Features/DiagnosticsTestUtilities/CodeActions/CodeFixVerifierHelper.cs - main - githubmirror/roslyn

src/Features/DiagnosticsTestUtilities/CodeActions/CodeFixVerifierHelper.cs
134 строки4 KB
Cyrus Najmabadi
Use file scoped namespaces. (#77854)
27 мар 2025, 09:55
27 мар 2025, 09:5598d41b8
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Diagnostics.Analyzers.NamingStyles;
using Microsoft.CodeAnalysis.Options;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Text;
using Roslyn.Utilities;
using Xunit;

namespace Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;

internal static class CodeFixVerifierHelper
{
    public static void VerifyStandardProperty(DiagnosticAnalyzer analyzer, AnalyzerProperty property)
    {
        switch (property)
        {
            case AnalyzerProperty.Title:
                VerifyMessageTitle(analyzer);
                return;

            case AnalyzerProperty.Description:
                VerifyMessageDescription(analyzer);
                return;

            case AnalyzerProperty.HelpLink:
                VerifyMessageHelpLinkUri(analyzer);
                return;

            default:
                throw ExceptionUtilities.UnexpectedValue(property);
        }
    }

    private static void VerifyMessageTitle(DiagnosticAnalyzer analyzer)
    {
        foreach (var descriptor in analyzer.SupportedDiagnostics)
        {
            if (descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.NotConfigurable))
            {
                // The title only displayed for rule configuration
                continue;
            }

            Assert.NotEqual("", descriptor.Title?.ToString() ?? "");
        }
    }

    private static void VerifyMessageDescription(DiagnosticAnalyzer analyzer)
    {
        foreach (var descriptor in analyzer.SupportedDiagnostics)
        {
            if (ShouldSkipMessageDescriptionVerification(descriptor))
            {
                continue;
            }

            Assert.NotEqual("", descriptor.MessageFormat?.ToString() ?? "");
        }

        return;

        // Local function
        static bool ShouldSkipMessageDescriptionVerification(DiagnosticDescriptor descriptor)
        {
            if (descriptor.ImmutableCustomTags().Contains(WellKnownDiagnosticTags.NotConfigurable))
            {
                if (!descriptor.IsEnabledByDefault || descriptor.DefaultSeverity == DiagnosticSeverity.Hidden)
                {
                    // The message only displayed if either enabled and not hidden, or configurable
                    return true;
                }
            }

            return false;
        }
    }

    private static void VerifyMessageHelpLinkUri(DiagnosticAnalyzer analyzer)
    {
        foreach (var descriptor in analyzer.SupportedDiagnostics)
        {
            Assert.NotEqual("", descriptor.HelpLinkUri ?? "");
        }
    }

    public static string? GetEditorConfigText(this OptionsCollection options)
    {
        var text = ConvertOptionsToAnalyzerConfig(options.DefaultExtension, explicitEditorConfig: string.Empty, options);
        return text?.ToString();
    }

    public static SourceText? ConvertOptionsToAnalyzerConfig(string defaultFileExtension, string? explicitEditorConfig, OptionsCollection options)
    {
        if (options.Count == 0)
        {
            return explicitEditorConfig is object ? SourceText.From(explicitEditorConfig, Encoding.UTF8) : null;
        }

        var analyzerConfig = new StringBuilder();
        if (explicitEditorConfig is object)
        {
            analyzerConfig.AppendLine(explicitEditorConfig);
        }
        else
        {
            analyzerConfig.AppendLine("root = true");
        }

        analyzerConfig.AppendLine();
        analyzerConfig.AppendLine($"[*.{defaultFileExtension}]");

        foreach (var (optionKey, value) in options)
        {
            Assert.True(optionKey.Option.Definition.IsEditorConfigOption);

            if (value is NamingStylePreferences namingStylePreferences)
            {
                namingStylePreferences.AppendToEditorConfig(optionKey.Language!, analyzerConfig);
                continue;
            }

            analyzerConfig.AppendLine($"{optionKey.Option.Definition.ConfigName} = {optionKey.Option.Definition.Serializer.Serialize(value)}");
        }

        return SourceText.From(analyzerConfig.ToString(), Encoding.UTF8);
    }
}