Ability to specify benchmark description in outputs

samples/BenchmarkDotNet.Samples/IntroRenameTest.cs

@@ -0,0 +1,22 @@
+using BenchmarkDotNet.Attributes;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace BenchmarkDotNet.Samples
+{
+    [BenchmarkDescription("Used to be 'IntroRenameTest', now is 'My Renamed Test'")]
+    public class IntroRenameTest
+    {
+        // And define a method with the Benchmark attribute
+        [Benchmark]
+        public void Sleep() => Thread.Sleep(10);
+
+        // You can write a description for your method.
+        [Benchmark(Description = "Thread.Sleep(10)")]
+        public void SleepWithDescription() => Thread.Sleep(10);
+    }
+}

src/BenchmarkDotNet.Annotations/Attributes/BenchmarkDescriptionAttribute.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace BenchmarkDotNet.Attributes
+{
+    public class BenchmarkDescriptionAttribute : Attribute
+    {
+        public BenchmarkDescriptionAttribute(){        }
+        public BenchmarkDescriptionAttribute(string description)
+            => Description = description;
+
+        public string Description { get; set; }
+    }
+}

src/BenchmarkDotNet/Columns/TargetMethodColumn.cs

@@ -8,7 +8,7 @@ namespace BenchmarkDotNet.Columns
     public class TargetMethodColumn : IColumn
     {
         public static readonly IColumn Namespace = new TargetMethodColumn(Column.Namespace, benchmark => benchmark.Descriptor.Type.Namespace);
-        public static readonly IColumn Type = new TargetMethodColumn(Column.Type, benchmark => benchmark.Descriptor.Type.GetDisplayName());
+        public static readonly IColumn Type = new TargetMethodColumn(Column.Type, benchmark => benchmark.Descriptor.TypeInfo);
         public static readonly IColumn Method = new TargetMethodColumn(Column.Method, benchmark => benchmark.Descriptor.WorkloadMethodDisplayInfo, true);
 
         private readonly Func<BenchmarkCase, string> valueProvider;

src/BenchmarkDotNet/Extensions/ReflectionExtensions.cs

@@ -102,6 +102,10 @@ private static IEnumerable<string> GetNestedTypeNames(Type type, bool includeGen
         /// </summary>
         private static string GetDisplayName(this TypeInfo typeInfo)
         {
+            var customAttr = typeInfo.GetCustomAttribute<BenchmarkDescriptionAttribute>();
+            if (customAttr != null)
+                return customAttr.Description;
+
             if (!typeInfo.IsGenericType)
                 return typeInfo.Name;
 

src/BenchmarkDotNet/Running/BenchmarkConverter.cs

@@ -119,6 +119,8 @@ private static IEnumerable<Descriptor> GetTargets(
             Tuple<MethodInfo, TargetedAttribute>[] iterationCleanupMethods,
             IConfig config)
         {
+            var abc = type.GetCustomAttributes(typeof(BenchmarkDescriptionAttribute), false);
+            var classDescriptionAttribute = type.ResolveAttribute<BenchmarkDescriptionAttribute>();
             return targetMethods
                 .Select(methodInfo => CreateDescriptor(type,
                                                    GetTargetedMatchingMethod(methodInfo, globalSetupMethods),
@@ -127,8 +129,10 @@ private static IEnumerable<Descriptor> GetTargets(
                                                    GetTargetedMatchingMethod(methodInfo, iterationSetupMethods),
                                                    GetTargetedMatchingMethod(methodInfo, iterationCleanupMethods),
                                                    methodInfo.ResolveAttribute<BenchmarkAttribute>(),
+                                                   classDescriptionAttribute,
+                                                   methodInfo.ResolveAttribute<BenchmarkDescriptionAttribute>(),
                                                    targetMethods,
-                                                   config));
+                                                   config)) ;
         }
 
         private static MethodInfo GetTargetedMatchingMethod(MethodInfo benchmarkMethod, Tuple<MethodInfo, TargetedAttribute>[] methods)
@@ -155,18 +159,25 @@ private static Descriptor CreateDescriptor(
             MethodInfo iterationSetupMethod,
             MethodInfo iterationCleanupMethod,
             BenchmarkAttribute attr,
+            BenchmarkDescriptionAttribute? classDescription,
+            BenchmarkDescriptionAttribute? methodDescription,
             MethodInfo[] targetMethods,
             IConfig config)
         {
             var categoryDiscoverer = config.CategoryDiscoverer ?? DefaultCategoryDiscoverer.Instance;
+            string description = attr?.Description;
+                if (description is null)
+                    description = methodDescription?.Description;
+                if (description is null)
+                    description = classDescription?.Description;
             var target = new Descriptor(
                 type,
                 methodInfo,
                 globalSetupMethod,
                 globalCleanupMethod,
                 iterationSetupMethod,
                 iterationCleanupMethod,
-                attr.Description,
+                description,
                 baseline: attr.Baseline,
                 categories: categoryDiscoverer.GetCategories(methodInfo),
                 operationsPerInvoke: attr.OperationsPerInvoke,

tests/BenchmarkDotNet.Tests/Exporters/MarkdownExporterVerifyTests.cs

@@ -195,6 +195,16 @@ [Benchmark] public void Bar() { }
 
             /* JobBaseline */
 
+            [RankColumn, LogicalGroupColumn, BaselineColumn]
+            [SimpleJob(id: "Job1"), SimpleJob(id: "Job2")]
+            [BenchmarkDotNet.Attributes.BenchmarkDescription(Description = "MyRenamedTestCase")]
+            public class JobBaseline_RenameJob_MethodsJobs
+            {
+                [Benchmark] public void Base() { }
+                [Benchmark] public void Foo() { }
+                [Benchmark] public void Bar() { }
+            }
+
             [RankColumn, LogicalGroupColumn, BaselineColumn]
             [SimpleJob(id: "Job1", baseline: true), SimpleJob(id: "Job2")]
             public class JobBaseline_MethodsJobs

tests/BenchmarkDotNet.Tests/Exporters/VerifiedFiles/MarkdownExporterApprovalTests.GroupExporterTest.JobBaseline_RenameJob_MethodsJobs.approved.txt

@@ -0,0 +1,20 @@
+=== JobBaseline_RenameJob_MethodsJobs ===
+
+BenchmarkDotNet=v0.10.x-mock, OS=Microsoft Windows NT 10.0.x.mock, VM=Hyper-V
+MockIntel Core i7-6700HQ CPU 2.60GHz (Max: 3.10GHz), 1 CPU, 8 logical and 4 physical cores
+Frequency=2531248 Hz, Resolution=395.0620 ns, Timer=TSC
+  [Host] : Clr 4.0.x.mock, 64mock RyuJIT-v4.6.x.mock CONFIGURATION
+  Job1   : extra output line
+  Job2   : extra output line
+
+
+ Method |  Job |     Mean |   Error |  StdDev | Rank | LogicalGroup | Baseline |
+------- |----- |---------:|--------:|--------:|-----:|------------- |--------- |
+   Base | Job1 | 102.0 ns | 6.09 ns | 1.58 ns |    1 |            * |       No |
+    Foo | Job1 | 202.0 ns | 6.09 ns | 1.58 ns |    2 |            * |       No |
+    Bar | Job1 | 302.0 ns | 6.09 ns | 1.58 ns |    3 |            * |       No |
+   Base | Job2 | 402.0 ns | 6.09 ns | 1.58 ns |    4 |            * |       No |
+    Foo | Job2 | 502.0 ns | 6.09 ns | 1.58 ns |    5 |            * |       No |
+    Bar | Job2 | 602.0 ns | 6.09 ns | 1.58 ns |    6 |            * |       No |
+
+Errors: 0

tests/BenchmarkDotNet.Tests/Running/BenchmarkConverterTests.cs

@@ -212,6 +212,26 @@ public void MethodDeclarationOrderIsPreserved()
                 Assert.Equal(nameof(BAC.C), info.BenchmarksCases[2].Descriptor.WorkloadMethod.Name);
             }
         }
+        [Fact]
+        public void DescriptorDescriptionNameOverride()
+        {
+            var description = BenchmarkConverter.TypeToBenchmarks(typeof(MethodDescriptionOverrideTests));
+
+            Assert.Equal("VoidTest", description.BenchmarksCases[0].Descriptor.WorkloadMethodDisplayInfo);
+            Assert.Equal("\'from Benchmark\'", description.BenchmarksCases[1].Descriptor.WorkloadMethodDisplayInfo);
+            Assert.Equal("OverrideFromAttribute", description.BenchmarksCases[2].Descriptor.WorkloadMethodDisplayInfo);
+            Assert.Equal("\'Who are the winner?\'", description.BenchmarksCases[3].Descriptor.WorkloadMethodDisplayInfo);
+        }
+        [Fact]
+        public void ClassDescriptorDescriptionNameOverride()
+        {
+            var description = BenchmarkConverter.TypeToBenchmarks(typeof(ClassDescriptionOverrideTests));
+
+            Assert.Equal("FromClassDescription", description.BenchmarksCases[0].Descriptor.WorkloadMethodDisplayInfo);
+            Assert.Equal("\'from Benchmark\'", description.BenchmarksCases[1].Descriptor.WorkloadMethodDisplayInfo);
+            Assert.Equal("OverrideFromAttribute", description.BenchmarksCases[2].Descriptor.WorkloadMethodDisplayInfo);
+            Assert.Equal("\'Who are the winner?\'", description.BenchmarksCases[3].Descriptor.WorkloadMethodDisplayInfo);
+        }
 
         public class BAC
         {
@@ -278,5 +298,38 @@ public class PrivateIterationCleanup
             [IterationCleanup] private void X() { }
             [Benchmark] public void A() { }
         }
+        public class MethodDescriptionOverrideTests
+        {
+            [Benchmark]
+            public void VoidTest() { }
+
+            [Benchmark(Description = "from Benchmark")]
+            public void BenchmarkAttributeOverride() {}
+
+            [Benchmark]
+            [BenchmarkDescription("OverrideFromAttribute")]
+            public void BenchmarkDescriptionAttributeOverride() { }
+
+            [Benchmark(Description = "Who are the winner?")]
+            [BenchmarkDescription("OverrideFromAttribute")]
+            public void BothAttributeOverride() { }
+        }
+        [BenchmarkDescription("FromClassDescription")]
+        public class ClassDescriptionOverrideTests
+        {
+            [Benchmark]
+            public void VoidTest() { }
+
+            [Benchmark(Description = "from Benchmark")]
+            public void ClassBenchmarkAttributeOverride() { }
+
+            [Benchmark]
+            [BenchmarkDescription("OverrideFromAttribute")]
+            public void ClassBenchmarkDescriptionAttributeOverride() { }
+
+            [Benchmark(Description = "Who are the winner?")]
+            [BenchmarkDescription("OverrideFromAttribute")]
+            public void ClassBothAttributeOverride() { }
+        }
     }
 }