Imported Upstream version 6.6.0.89

Former-commit-id: b39a328747c2f3414dc52e009fb6f0aa80ca2492

external/api-doc-tools/mdoc/mdoc.Test/BasicFormatterTests.cs

@@ -0,0 +1,157 @@
+using System;
+using System.Linq;
+using Mono.Cecil;
+using Mono.Documentation.Updater;
+using NUnit.Framework;
+
+namespace mdoc.Test
+{
+    public abstract class BasicFormatterTests<T> : BasicTests where T : MemberFormatter
+    {
+        protected abstract T formatter { get; }
+
+        protected MethodDefinition GetProperty(TypeDefinition testclass, Func<MethodDefinition, bool> query)
+        {
+            var methods = testclass.Methods;
+            var member = methods.FirstOrDefault(query)?.Resolve();
+            if (member == null)
+                throw new Exception("Did not find the member in the test class");
+            return member;
+        }
+
+        protected MemberReference GetProperty(TypeDefinition type, string memberName)
+        {
+            var property = type.Properties.FirstOrDefault(i => i.Name == memberName);
+            if (property == null)
+                throw new Exception($"Can't find property {memberName}");
+            return property;
+        }
+
+        protected MemberReference GetField(TypeDefinition type, string eventName)
+        {
+            var property = type.Fields.SingleOrDefault(i => i.Name == eventName);
+            if (property == null)
+                throw new Exception($"Can't find field {eventName}");
+            return property;
+        }
+
+        protected MemberReference GetEvent(TypeDefinition type, string eventName)
+        {
+            var property = type.Events.SingleOrDefault(i => i.Name == eventName);
+            if (property == null)
+                throw new Exception($"Can't find field {eventName}");
+            return property;
+        }
+
+        protected void TestTypeSignature(Type type, string expected)
+        {
+            expected = FormatEndings(expected);
+            var signature = GetTypeSignature(type);
+            Assert.AreEqual(expected, signature);
+        }
+
+        protected void TestTypeSignature(string libPath, string fullTypeName, string expected)
+        {
+            expected = FormatEndings(expected);
+            var type = GetType(libPath, fullTypeName);
+            var signature = formatter.GetDeclaration(type);
+            Assert.AreEqual(expected, signature);
+        }
+
+        private string GetTypeSignature(Type type)
+        {
+            var tref = GetType(type);
+            var signature = formatter.GetDeclaration(tref);
+            return signature;
+        }
+
+        protected void TestMethodSignature(Type type, string expected, string memberName)
+        {
+            var signature = GetMethodSignature(type, memberName);
+            Assert.AreEqual(FormatEndings(expected), signature);
+        }
+
+        protected void TestMethodSignature(string libPath, string fullTypeName, string memberName, string expected)
+        {
+            var type = GetType(libPath, fullTypeName);
+            var method = GetMethod(type, i => i.Name == memberName);
+            var signature = formatter.GetDeclaration(method);
+            Assert.AreEqual(FormatEndings(expected), signature);
+        }
+        
+        private string GetMethodSignature(Type type, string memberName)
+        {
+            var tref = GetType(type);
+            var method = GetMethod(tref, i => i.Name == memberName);
+            var signature = formatter.GetDeclaration(method);
+            return signature;
+        }
+
+        protected void TestPropertySignature(Type type, string expected, string memberName)
+        {
+            var signature = GetPropertySignature(type, memberName);
+            Assert.AreEqual(FormatEndings(expected), signature);
+        }
+
+        private string GetPropertySignature(Type type, string memberName)
+        {
+            var tref = GetType(type);
+            return formatter.GetDeclaration(GetProperty(tref, memberName));
+        }
+
+        protected void TestPropertySignature(string libPath, string fullTypeName, string memberName, string expected)
+        {
+            var type = GetType(libPath, fullTypeName);
+            var property = GetProperty(type, memberName);
+            var signature = formatter.GetDeclaration(property);
+            Assert.AreEqual(FormatEndings(expected), signature);
+        }
+
+        protected void TestEventSignature(Type type, string expected, string memberName)
+        {
+            var signature = GetEventSignature(type, memberName);
+            Assert.AreEqual(expected, signature);
+        }
+
+        private string GetEventSignature(Type type, string memberName)
+        {
+            var tref = GetType(type);
+            return formatter.GetDeclaration(GetEvent(tref, memberName));
+        }
+
+        protected void TestEventSignature(string libPath, string fullTypeName, string memberName, string expected)
+        {
+            var type = GetType(libPath, fullTypeName);
+            var @event = GetEvent(type, memberName);
+            var signature = formatter.GetDeclaration(@event);
+            Assert.AreEqual(FormatEndings(expected), signature);
+        }
+
+        protected void TestFieldSignature(Type type, string expected, string memberName)
+        {
+            var usage = GetFieldUsage(type, memberName);
+            Assert.AreEqual(FormatEndings(expected), usage);
+        }
+
+        private string GetFieldUsage(Type type, string memberName)
+        {
+            var tref = GetType(type);
+            var field = GetField(tref, memberName);
+            var signature = formatter.GetDeclaration(field);
+            return signature;
+        }
+
+        protected void TestFieldSignature(string libPath, string fullTypeName, string memberName, string expected)
+        {
+            var type = GetType(libPath, fullTypeName);
+            var field = GetField(type, memberName);
+            var signature = formatter.GetDeclaration(field);
+            Assert.AreEqual(FormatEndings(expected), signature);
+        }
+
+        protected static string FormatEndings(string s)
+        {
+            return s?.Replace("\r\n", MemberFormatter.GetLineEnding());
+        }
+    }
+}