private static void ValidateHover()

in src/Bicep.LangServer.IntegrationTests/HoverTests.cs [1243:1355]
91 lines of code
22 McCabe index (conditional complexity)

        private static void ValidateHover(Hover? hover, Symbol symbol)
        {
            hover.Should().NotBeNull();
            hover!.Range!.Should().NotBeNull();
            hover.Contents.Should().NotBeNull();

            List<string> tooltips = new();
            if (hover.Contents.HasMarkedStrings)
            {
                tooltips.AddRange(hover.Contents.MarkedStrings!.Select(ms => ms.Value));
            }
            else
            {
                hover.Contents.MarkupContent!.Kind.Should().Be(MarkupKind.Markdown);
                tooltips.Add(hover.Contents.MarkupContent!.Value);
            }

            foreach (var tooltip in tooltips)
            {
                tooltip.Should().StartWith("```bicep\n");
                Regex.Matches(tooltip, "```").Count.Should().Be(2);

                switch (symbol)
                {

                    case MetadataSymbol metadata:
                        tooltip.Should().Contain($"metadata {metadata.Name}: {metadata.Type}");
                        break;

                    case ParameterSymbol parameter:
                        tooltip.Should().Contain($"param {parameter.Name}: {parameter.Type}");
                        break;

                    case TypeAliasSymbol declaredType:
                        tooltip.Should().Contain($"type {declaredType.Name}: {declaredType.Type}");
                        break;

                    case ImportedTypeSymbol importedType:
                        tooltip.Should().Contain($"type {importedType.Name}: {importedType.Type}");
                        break;

                    case AmbientTypeSymbol ambientType:
                        tooltip.Should().Contain($"type {ambientType.Name}: {ambientType.Type}");
                        break;

                    case VariableSymbol variable:
                        // the hovers with errors don't appear in VS code and only occur in tests
                        tooltip.Should().ContainAny([$"var {variable.Name}: {variable.Type}", $"var {variable.Name}: error"]);
                        break;

                    case ImportedVariableSymbol importedVariable:
                        tooltip.Should().Contain($"var {importedVariable.Name}: {importedVariable.Type}");
                        break;

                    case TestSymbol variable:
                        // the hovers with errors don't appear in VS code and only occur in tests
                        tooltip.Should().ContainAny([$"test {variable.Name}", $"var {variable.Name}"]);
                        break;

                    case ResourceSymbol resource:
                        tooltip.Should().Contain($"resource {resource.Name}");
                        tooltip.Should().Contain(resource.Type.Name);
                        break;

                    case ModuleSymbol module:
                        tooltip.Should().Contain($"module {module.Name}");
                        break;

                    case OutputSymbol output:
                        tooltip.Should().Contain($"output {output.Name}: {output.Type}");
                        break;

                    case FunctionSymbol function:
                        if (function.Overloads.All(fo => fo is FunctionWildcardOverload))
                        {
                            tooltip.Should().Contain($"function ");
                            tooltip.Should().Contain($"*(");
                        }
                        else
                        {
                            tooltip.Should().Contain($"function {function.Name}(");
                        }
                        break;

                    case DeclaredFunctionSymbol declaredFunction:
                        tooltip.Should().Contain($"function {declaredFunction.Name}(");
                        break;

                    case ImportedFunctionSymbol importedFunction:
                        tooltip.Should().Contain($"function {importedFunction.Name}(");
                        break;

                    case LocalVariableSymbol local:
                        tooltip.Should().Contain($"{local.Name}: {local.Type}");
                        break;

                    case ExtensionNamespaceSymbol extension:
                        tooltip.Should().Contain($"extension {extension.Name}");
                        break;

                    case BuiltInNamespaceSymbol @namespace:
                        tooltip.Should().Contain($"{@namespace.Name} namespace");
                        break;

                    case WildcardImportSymbol wildcardImport:
                        tooltip.Should().Contain($"{wildcardImport.Name} namespace");
                        break;

                    default:
                        throw new AssertFailedException($"Unexpected symbol type '{symbol.GetType().Name}'");
                }
            }
        }