diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 0000000..2d9226a
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,117 @@
+# To learn more about .editorconfig see https://aka.ms/editorconfigdocs
+############################### 
+# Core EditorConfig Options   # 
+############################### 
+# All files 
+[*] 
+indent_style = space 
+# Code files 
+[*.{cs,csx,vb,vbx}] 
+indent_size = 4 
+insert_final_newline = true 
+charset = utf-8-bom 
+############################### 
+# .NET Coding Conventions     # 
+############################### 
+[*.{cs,vb}] 
+# Organize usings 
+dotnet_sort_system_directives_first = true:suggestion
+# this. preferences 
+dotnet_style_qualification_for_field = true:warning
+dotnet_style_qualification_for_property = true:warning
+dotnet_style_qualification_for_method = true:warning
+dotnet_style_qualification_for_event = true:warning
+# Language keywords vs BCL types preferences 
+dotnet_style_predefined_type_for_locals_parameters_members = true:warning
+dotnet_style_predefined_type_for_member_access = true:warning
+# Parentheses preferences 
+dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:suggestion
+dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:suggestion
+dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:suggestion
+dotnet_style_parentheses_in_other_operators = never_if_unnecessary:suggestion
+# Modifier preferences 
+dotnet_style_require_accessibility_modifiers = for_non_interface_members:suggestion 
+dotnet_style_readonly_field = true:suggestion 
+# Expression-level preferences 
+dotnet_style_object_initializer = true:suggestion 
+dotnet_style_collection_initializer = true:suggestion 
+dotnet_style_explicit_tuple_names = true:suggestion 
+dotnet_style_null_propagation = true:suggestion 
+dotnet_style_coalesce_expression = true:suggestion 
+dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion 
+dotnet_prefer_inferred_tuple_names = true:suggestion 
+dotnet_prefer_inferred_anonymous_type_member_names = true:suggestion 
+dotnet_style_prefer_auto_properties = true:suggestion 
+dotnet_style_prefer_conditional_expression_over_assignment = true:suggestion 
+dotnet_style_prefer_conditional_expression_over_return = false:warning 
+############################### 
+# Naming Conventions          # 
+############################### 
+# Style Definitions 
+dotnet_naming_style.pascal_case_style.capitalization             = pascal_case 
+# Use PascalCase for constant fields   
+dotnet_naming_rule.constant_fields_should_be_pascal_case.severity = suggestion 
+dotnet_naming_rule.constant_fields_should_be_pascal_case.symbols  = constant_fields 
+dotnet_naming_rule.constant_fields_should_be_pascal_case.style    = pascal_case_style 
+dotnet_naming_symbols.constant_fields.applicable_kinds            = field 
+dotnet_naming_symbols.constant_fields.applicable_accessibilities  = * 
+dotnet_naming_symbols.constant_fields.required_modifiers          = const 
+############################### 
+# C# Coding Conventions       # 
+############################### 
+[*.cs] 
+# var preferences 
+csharp_style_var_for_built_in_types = true 
+csharp_style_var_when_type_is_apparent = true
+csharp_style_var_elsewhere = true
+# Expression-bodied members 
+csharp_style_expression_bodied_methods = false:suggestion
+csharp_style_expression_bodied_constructors = false:suggestion
+csharp_style_expression_bodied_operators = false:suggestion
+csharp_style_expression_bodied_properties = true:suggestion
+csharp_style_expression_bodied_indexers = true:suggestion
+csharp_style_expression_bodied_accessors = true:suggestion
+# Pattern matching preferences
+csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion
+csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
+# Null-checking preferences 
+csharp_style_throw_expression = true:suggestion
+csharp_style_conditional_delegate_call = true:suggestion
+# Modifier preferences 
+csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:error
+# Expression-level preferences 
+csharp_prefer_braces = true:silent
+csharp_style_deconstructed_variable_declaration = true:suggestion
+csharp_prefer_simple_default_expression = true:suggestion
+csharp_style_pattern_local_over_anonymous_function = true:suggestion
+csharp_style_inlined_variable_declaration = true:suggestion
+############################### 
+# C# Formatting Rules         # 
+############################### 
+# New line preferences 
+csharp_new_line_before_open_brace = all
+csharp_new_line_before_else = true
+csharp_new_line_before_catch = true
+csharp_new_line_before_finally = true
+csharp_new_line_before_members_in_object_initializers = true
+csharp_new_line_before_members_in_anonymous_types = true
+csharp_new_line_between_query_expression_clauses = true
+# Indentation preferences
+csharp_indent_case_contents = true
+csharp_indent_switch_labels = true
+csharp_indent_labels = flush_left
+# Space preferences
+csharp_space_after_cast = false
+csharp_space_after_keywords_in_control_flow_statements = true
+csharp_space_between_method_call_parameter_list_parentheses = false
+csharp_space_between_method_declaration_parameter_list_parentheses = false
+csharp_space_between_parentheses = false
+csharp_space_before_colon_in_inheritance_clause = true
+csharp_space_after_colon_in_inheritance_clause = true
+csharp_space_around_binary_operators = before_and_after
+csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
+csharp_space_between_method_call_name_and_opening_parenthesis = false
+csharp_space_between_method_call_empty_parameter_list_parentheses = false
+# Wrapping preferences
+csharp_preserve_single_line_statements = true
+csharp_preserve_single_line_blocks = false
diff --git a/GitVersion.yml b/GitVersion.yml
index 4c4932b..09e2e36 100644
--- a/GitVersion.yml
+++ b/GitVersion.yml
@@ -1,4 +1,4 @@
-mode: Mainline
+mode: ContinuousDelivery
 branches: {}
 ignore:
   sha: []
diff --git a/LivingDocumentation.sln b/LivingDocumentation.sln
index 7c54e10..147bad9 100644
--- a/LivingDocumentation.sln
+++ b/LivingDocumentation.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 16
-VisualStudioVersion = 16.0.29009.5
+VisualStudioVersion = 16.0.29318.209
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LivingDocumentation.Analyzer", "src\LivingDocumentation.Analyzer\LivingDocumentation.Analyzer.csproj", "{72E336A0-A9D8-494D-9332-CDE8341B247B}"
 EndProject
@@ -27,7 +27,15 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "samples", "samples", "{742D
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{93C52A66-6790-47D3-90A7-26EFFC41D4C6}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LivingDocumentation.Analyzer.Tests", "tests\LivingDocumentation.Analyzer.Tests\LivingDocumentation.Analyzer.Tests.csproj", "{90E0C6A2-BF79-406D-BC5C-2637AD2BADE2}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LivingDocumentation.Analyzer.Tests", "tests\LivingDocumentation.Analyzer.Tests\LivingDocumentation.Analyzer.Tests.csproj", "{90E0C6A2-BF79-406D-BC5C-2637AD2BADE2}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{4FC1E9E3-E30A-47E2-BBFD-D1105EF4710F}"
+	ProjectSection(SolutionItems) = preProject
+		.editorconfig = .editorconfig
+		GitVersion.yml = GitVersion.yml
+	EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LivingDocumentation.RenderExtensions.Tests", "tests\LivingDocumentation.RenderExtensions.Tests\LivingDocumentation.RenderExtensions.Tests.csproj", "{0A28D3CE-00A8-4473-B571-F8AE0FFFF1AC}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -75,6 +83,10 @@ Global
 		{90E0C6A2-BF79-406D-BC5C-2637AD2BADE2}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{90E0C6A2-BF79-406D-BC5C-2637AD2BADE2}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{90E0C6A2-BF79-406D-BC5C-2637AD2BADE2}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0A28D3CE-00A8-4473-B571-F8AE0FFFF1AC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0A28D3CE-00A8-4473-B571-F8AE0FFFF1AC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0A28D3CE-00A8-4473-B571-F8AE0FFFF1AC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0A28D3CE-00A8-4473-B571-F8AE0FFFF1AC}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -90,6 +102,7 @@ Global
 		{43F54404-225C-4234-AFA9-A316A891884C} = {2CCF1B57-05F0-4DF7-8B48-29D03CE052F5}
 		{4CC5B483-9205-47A4-82F8-189047316512} = {2CCF1B57-05F0-4DF7-8B48-29D03CE052F5}
 		{90E0C6A2-BF79-406D-BC5C-2637AD2BADE2} = {93C52A66-6790-47D3-90A7-26EFFC41D4C6}
+		{0A28D3CE-00A8-4473-B571-F8AE0FFFF1AC} = {93C52A66-6790-47D3-90A7-26EFFC41D4C6}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {298BF1F6-9407-40A1-91C0-F11BA01BD95B}
diff --git a/samples/LivingDocumentation.eShopOnContainers/AsciiDocRenderer.cs b/samples/LivingDocumentation.eShopOnContainers/AsciiDocRenderer.cs
index 5ebace4..25f4e8b 100644
--- a/samples/LivingDocumentation.eShopOnContainers/AsciiDocRenderer.cs
+++ b/samples/LivingDocumentation.eShopOnContainers/AsciiDocRenderer.cs
@@ -1,265 +1,265 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using System.Text;
-using System.Text.RegularExpressions;
-
-namespace LivingDocumentation.eShopOnContainers
-{
-    public class AsciiDocRenderer
-    {
-        private readonly IReadOnlyList<TypeDescription> types;
-        private readonly IReadOnlyDictionary<string, string> aggregateFiles;
-        private readonly IReadOnlyDictionary<string, string> commandHandlerFiles;
-        private readonly IReadOnlyDictionary<string, string> eventHandlerFiles;
-        private static readonly Regex replaceTypeSuffix = new Regex("(?:(?:Command|(?:Domain|Integration)Event))(?:Handler)?$", RegexOptions.CultureInvariant);
-
-        public AsciiDocRenderer(IReadOnlyList<TypeDescription> types, IReadOnlyDictionary<string, string> aggregateFiles, IReadOnlyDictionary<string, string> commandHandlerFiles, IReadOnlyDictionary<string, string> eventHandlerFiles)
-        {
-            this.types = types;
-            this.aggregateFiles = aggregateFiles;
-            this.commandHandlerFiles = commandHandlerFiles;
-            this.eventHandlerFiles = eventHandlerFiles;
-        }
-
-        public void Render()
-        {
-            var stringBuilder = new StringBuilder();
-
-            RenderFileHeader(stringBuilder);
-
-            RenderAggregates(stringBuilder);
-            RenderCommands(stringBuilder);
-            RenderCommandHandlers(stringBuilder);
-            RenderDomainEvents(stringBuilder);
-            RenderDomainEventHandlers(stringBuilder);
-            RenderIntegrationEvents(stringBuilder);
-
-            File.WriteAllText("documentation.generated.adoc", stringBuilder.ToString());
-        }
-
-        private void RenderAggregates(StringBuilder stringBuilder)
-        {
-            stringBuilder.AppendLine();
-            stringBuilder.AppendLine("// tag::aggregates[]");
-            stringBuilder.AppendLine("== Aggregates");
-            stringBuilder.AppendLine("Aggregates in the eShop application.");
-
-            foreach (var (type, path) in this.aggregateFiles.Select(kv => (Type: this.types.FirstOrDefault(kv.Key), Path: kv.Value)).OrderBy(t => t.Type.Name))
-            {
-                stringBuilder.AppendLine();
-                stringBuilder.AppendLine($"// tag::aggregate-{StripTypeSuffix(type.Name).ToLowerInvariant()}[]");
-                stringBuilder.AppendLine($"=== {type.Name}");
-                stringBuilder.AppendLine($"The \"`{type.Name.ToLower()}`\" aggregate.");
-                stringBuilder.AppendLine();
-                stringBuilder.AppendLine($".{FormatTechnicalName(type.Name)}");
-                stringBuilder.AppendLine($"[plantuml, aggregate.{StripTypeSuffix(type.Name).ToLowerInvariant()}, png]");
-                stringBuilder.AppendLine("....");
-                stringBuilder.AppendLine($"include::{path}[]");
-                stringBuilder.AppendLine("....");
-                stringBuilder.AppendLine($"// end::aggregate-{StripTypeSuffix(type.Name).ToLowerInvariant()}[]");
-            }
-
-            stringBuilder.AppendLine("// end::aggregates[]");
-        }
-
-        private void RenderCommands(StringBuilder stringBuilder)
-        {
-            stringBuilder.AppendLine();
-            stringBuilder.AppendLine("// tag::commands[]");
-            stringBuilder.AppendLine("== Commands");
-            stringBuilder.AppendLine("Commands in the eShop application.");
-
-            foreach (var type in this.types.Where(t => t.IsCommand() && !t.FullName.IsGeneric()).OrderBy(t => t.Name))
-            {
-                stringBuilder.AppendLine();
-                stringBuilder.AppendLine($"=== {FormatTechnicalName(type.Name)}");
-                stringBuilder.AppendLine($"The \"`{FormatTechnicalName(type.Name).ToLower()}`\" command.");
-                stringBuilder.AppendLine();
-
-                if (!string.IsNullOrWhiteSpace(type.Documentation))
-                {
-                    stringBuilder.AppendLine(type.Documentation);
-                    stringBuilder.AppendLine();
-                }
-
-                stringBuilder.AppendLine($".{type.Name.ToSentenceCase()} Fields");
-                stringBuilder.AppendLine("[%header%,width=\"75%\",cols=\"2h,3d\"]");
-                stringBuilder.AppendLine("|===");
-                stringBuilder.AppendLine("|Name|Type");
-
-                foreach (var property in type.Properties)
-                {
-                    stringBuilder.AppendLine($"|{property.Name}|{property.Type.ForDiagram()}");
-                }
-
-                stringBuilder.AppendLine("|===");
-            }
-
-            stringBuilder.AppendLine("// end::commands[]");
-        }
-
-        private void RenderCommandHandlers(StringBuilder stringBuilder)
-        {
-            stringBuilder.AppendLine();
-            stringBuilder.AppendLine("// tag::commandhandlers[]");
-            stringBuilder.AppendLine("== Command Handlers");
-            stringBuilder.AppendLine("Command handlers in the eShop application.");
-
-            foreach (var (type, path) in this.commandHandlerFiles.Select(kv => (Type: this.types.FirstOrDefault(kv.Key), Path: kv.Value)).OrderBy(t => t.Type.Name))
-            {
-                stringBuilder.AppendLine();
-                stringBuilder.AppendLine($"// tag::commandhandler-{StripTypeSuffix(type.Name).ToLowerInvariant()}[]");
-                stringBuilder.AppendLine($"=== {FormatTechnicalName(type.Name)}");
-                stringBuilder.AppendLine($"The \"`{FormatTechnicalName(type.Name).ToLower()}`\" command handler.");
-
-                if (!string.IsNullOrWhiteSpace(type.Documentation))
-                {
-                    stringBuilder.AppendLine(type.Documentation);
-                    stringBuilder.AppendLine();
-                }
-
-                stringBuilder.AppendLine();
-                stringBuilder.AppendLine($".{FormatTechnicalName(type.Name)}");
-                stringBuilder.AppendLine($"[plantuml, commandhandler.{StripTypeSuffix(type.Name).ToLowerInvariant()}, png]");
-                stringBuilder.AppendLine("....");
-                stringBuilder.AppendLine($"include::{path}[]");
-                stringBuilder.AppendLine("....");
-                stringBuilder.AppendLine($"// end::commandhandler-{StripTypeSuffix(type.Name).ToLowerInvariant()}[]");
-            }
-
-            stringBuilder.AppendLine("// end::commandhandlers[]");
-        }
-
-        private void RenderDomainEvents(StringBuilder stringBuilder)
-        {
-            stringBuilder.AppendLine();
-            stringBuilder.AppendLine("// tag::domainevents[]");
-            stringBuilder.AppendLine("== Domain Events");
-            stringBuilder.AppendLine("Domain events in the eShop application.");
-
-            foreach (var type in this.types.Where(t => t.IsDomainEvent()).OrderBy(t => t.Name))
-            {
-                stringBuilder.AppendLine();
-                stringBuilder.AppendLine($"=== {FormatTechnicalName(type.Name)}");
-                stringBuilder.AppendLine($"The \"`{FormatTechnicalName(type.Name).ToLower()}`\" domain event.");
-                stringBuilder.AppendLine();
-
-                if (!string.IsNullOrWhiteSpace(type.Documentation))
-                {
-                    stringBuilder.AppendLine(type.Documentation);
-                    stringBuilder.AppendLine();
-                }
-
-                stringBuilder.AppendLine($".{type.Name.ToSentenceCase()} Fields");
-                stringBuilder.AppendLine("[%header%,width=\"75%\",cols=\"2h,3d\"]");
-                stringBuilder.AppendLine("|===");
-                stringBuilder.AppendLine("|Name|Type");
-
-                foreach (var property in type.Properties)
-                {
-                    stringBuilder.AppendLine($"|{property.Name}|{property.Type.ForDiagram()}");
-                }
-
-                stringBuilder.AppendLine("|===");
-            }
-
-            stringBuilder.AppendLine("// end::domainevents[]");
-        }
-
-        private void RenderDomainEventHandlers(StringBuilder stringBuilder)
-        {
-            stringBuilder.AppendLine();
-            stringBuilder.AppendLine("// tag::domaineventhandlers[]");
-            stringBuilder.AppendLine("== Domain Event Handlers");
-            stringBuilder.AppendLine("Domain event handlers in the eShop application.");
-
-            foreach (var (type, path) in this.eventHandlerFiles.Select(kv => (Type: this.types.FirstOrDefault(kv.Key), Path: kv.Value)).OrderBy(t => t.Type.Name))
-            {
-                stringBuilder.AppendLine();
-                stringBuilder.AppendLine($"// tag::domaineventhandler-{StripTypeSuffix(type.Name).ToLowerInvariant()}[]");
-                stringBuilder.AppendLine($"=== {FormatTechnicalName(type.Name)}");
-                stringBuilder.AppendLine($"The \"`{FormatTechnicalName(type.Name).ToLower()}`\" event handler.");
-
-                if (!string.IsNullOrWhiteSpace(type.Documentation))
-                {
-                    stringBuilder.AppendLine(type.Documentation);
-                    stringBuilder.AppendLine();
-                }
-
-                stringBuilder.AppendLine();
-                stringBuilder.AppendLine($".{FormatTechnicalName(type.Name)}");
-                stringBuilder.AppendLine($"[plantuml, domaineventhandler.{StripTypeSuffix(type.Name).ToLowerInvariant()}, png]");
-                stringBuilder.AppendLine("....");
-                stringBuilder.AppendLine($"include::{path}[]");
-                stringBuilder.AppendLine("....");
-                stringBuilder.AppendLine($"// end::domaineventhandler-{StripTypeSuffix(type.Name).ToLowerInvariant()}[]");
-            }
-
-            stringBuilder.AppendLine("// end::domaineventhandlers[]");
-        }
-        private void RenderIntegrationEvents(StringBuilder stringBuilder)
-        {
-            stringBuilder.AppendLine();
-            stringBuilder.AppendLine("// tag::integrationevents[]");
-            stringBuilder.AppendLine("== Integration Events");
-            stringBuilder.AppendLine("Integration events in the eShop application.");
-
-            foreach (var type in this.types.Where(t => t.IsIntegrationEvent() && t.FullName.StartsWith("Ordering.API", StringComparison.Ordinal)).OrderBy(t => t.Name))
-            {
-                stringBuilder.AppendLine();
-                stringBuilder.AppendLine($"=== {FormatTechnicalName(type.Name)}");
-                stringBuilder.AppendLine($"The \"`{FormatTechnicalName(type.Name).ToLower()}`\" integration event.");
-                stringBuilder.AppendLine();
-
-                if (!string.IsNullOrWhiteSpace(type.Documentation))
-                {
-                    stringBuilder.AppendLine(type.Documentation);
-                    stringBuilder.AppendLine();
-                }
-
-                stringBuilder.AppendLine($".{type.Name.ToSentenceCase()} Fields");
-                stringBuilder.AppendLine("[%header%,width=\"75%\",cols=\"2h,3d\"]");
-                stringBuilder.AppendLine("|===");
-                stringBuilder.AppendLine("|Name|Type");
-
-                foreach (var property in type.Properties)
-                {
-                    stringBuilder.AppendLine($"|{property.Name}|{property.Type.ForDiagram()}");
-                }
-
-                stringBuilder.AppendLine("|===");
-            }
-
-            stringBuilder.AppendLine("// end::integrationevents[]");
-        }
-
-        private static void RenderFileHeader(StringBuilder stringBuilder)
-        {
-            stringBuilder.AppendLine("= Generated documentation");
-            stringBuilder.AppendLine("Michaël Hompus <michael@hompus.nl>");
-            stringBuilder.AppendLine($"{Assembly.GetEntryAssembly().GetName().Version.ToString(3)}, {DateTime.Today:yyyy-MM-dd}");
-            stringBuilder.AppendLine(":toc: left");
-            stringBuilder.AppendLine(":toc-level: 2");
-            stringBuilder.AppendLine(":sectnums:");
-            stringBuilder.AppendLine(":icons: font");
-            stringBuilder.AppendLine();
-            stringBuilder.AppendLine("NOTE: This document has been automatically generated");
-            stringBuilder.AppendLine();
-            stringBuilder.AppendLine("The documentation is generated from the source code of https://github.com/dotnet-architecture/eShopOnContainers[eShopOnContainers^].");
-            stringBuilder.AppendLine();
-        }
-
-        private static string StripTypeSuffix(string name)
-        {
-            return replaceTypeSuffix.Replace(name, string.Empty);
-        }
-
-        private static string FormatTechnicalName(string name)
-        {
-            return StripTypeSuffix(name).ToSentenceCase();
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace LivingDocumentation.eShopOnContainers
+{
+    public class AsciiDocRenderer
+    {
+        private readonly IReadOnlyList<TypeDescription> types;
+        private readonly IReadOnlyDictionary<string, string> aggregateFiles;
+        private readonly IReadOnlyDictionary<string, string> commandHandlerFiles;
+        private readonly IReadOnlyDictionary<string, string> eventHandlerFiles;
+        private static readonly Regex replaceTypeSuffix = new Regex("(?:(?:Command|(?:Domain|Integration)Event))(?:Handler)?$", RegexOptions.CultureInvariant);
+
+        public AsciiDocRenderer(IReadOnlyList<TypeDescription> types, IReadOnlyDictionary<string, string> aggregateFiles, IReadOnlyDictionary<string, string> commandHandlerFiles, IReadOnlyDictionary<string, string> eventHandlerFiles)
+        {
+            this.types = types;
+            this.aggregateFiles = aggregateFiles;
+            this.commandHandlerFiles = commandHandlerFiles;
+            this.eventHandlerFiles = eventHandlerFiles;
+        }
+
+        public void Render()
+        {
+            var stringBuilder = new StringBuilder();
+
+            RenderFileHeader(stringBuilder);
+
+            this.RenderAggregates(stringBuilder);
+            this.RenderCommands(stringBuilder);
+            this.RenderCommandHandlers(stringBuilder);
+            this.RenderDomainEvents(stringBuilder);
+            this.RenderDomainEventHandlers(stringBuilder);
+            this.RenderIntegrationEvents(stringBuilder);
+
+            File.WriteAllText("documentation.generated.adoc", stringBuilder.ToString());
+        }
+
+        private void RenderAggregates(StringBuilder stringBuilder)
+        {
+            stringBuilder.AppendLine();
+            stringBuilder.AppendLine("// tag::aggregates[]");
+            stringBuilder.AppendLine("== Aggregates");
+            stringBuilder.AppendLine("Aggregates in the eShop application.");
+
+            foreach (var (type, path) in this.aggregateFiles.Select(kv => (Type: this.types.FirstOrDefault(kv.Key), Path: kv.Value)).OrderBy(t => t.Type.Name))
+            {
+                stringBuilder.AppendLine();
+                stringBuilder.AppendLine($"// tag::aggregate-{StripTypeSuffix(type.Name).ToLowerInvariant()}[]");
+                stringBuilder.AppendLine($"=== {type.Name}");
+                stringBuilder.AppendLine($"The \"`{type.Name.ToLower()}`\" aggregate.");
+                stringBuilder.AppendLine();
+                stringBuilder.AppendLine($".{FormatTechnicalName(type.Name)}");
+                stringBuilder.AppendLine($"[plantuml, aggregate.{StripTypeSuffix(type.Name).ToLowerInvariant()}, png]");
+                stringBuilder.AppendLine("....");
+                stringBuilder.AppendLine($"include::{path}[]");
+                stringBuilder.AppendLine("....");
+                stringBuilder.AppendLine($"// end::aggregate-{StripTypeSuffix(type.Name).ToLowerInvariant()}[]");
+            }
+
+            stringBuilder.AppendLine("// end::aggregates[]");
+        }
+
+        private void RenderCommands(StringBuilder stringBuilder)
+        {
+            stringBuilder.AppendLine();
+            stringBuilder.AppendLine("// tag::commands[]");
+            stringBuilder.AppendLine("== Commands");
+            stringBuilder.AppendLine("Commands in the eShop application.");
+
+            foreach (var type in this.types.Where(t => t.IsCommand() && !t.FullName.IsGeneric()).OrderBy(t => t.Name))
+            {
+                stringBuilder.AppendLine();
+                stringBuilder.AppendLine($"=== {FormatTechnicalName(type.Name)}");
+                stringBuilder.AppendLine($"The \"`{FormatTechnicalName(type.Name).ToLower()}`\" command.");
+                stringBuilder.AppendLine();
+
+                if (!string.IsNullOrWhiteSpace(type.DocumentationComments?.Summary))
+                {
+                    stringBuilder.AppendLine(type.DocumentationComments.Summary);
+                    stringBuilder.AppendLine();
+                }
+
+                stringBuilder.AppendLine($".{type.Name.ToSentenceCase()} Fields");
+                stringBuilder.AppendLine("[%header%,width=\"75%\",cols=\"2h,3d\"]");
+                stringBuilder.AppendLine("|===");
+                stringBuilder.AppendLine("|Name|Type");
+
+                foreach (var property in type.Properties)
+                {
+                    stringBuilder.AppendLine($"|{property.Name}|{property.Type.ForDiagram()}");
+                }
+
+                stringBuilder.AppendLine("|===");
+            }
+
+            stringBuilder.AppendLine("// end::commands[]");
+        }
+
+        private void RenderCommandHandlers(StringBuilder stringBuilder)
+        {
+            stringBuilder.AppendLine();
+            stringBuilder.AppendLine("// tag::commandhandlers[]");
+            stringBuilder.AppendLine("== Command Handlers");
+            stringBuilder.AppendLine("Command handlers in the eShop application.");
+
+            foreach (var (type, path) in this.commandHandlerFiles.Select(kv => (Type: this.types.FirstOrDefault(kv.Key), Path: kv.Value)).OrderBy(t => t.Type.Name))
+            {
+                stringBuilder.AppendLine();
+                stringBuilder.AppendLine($"// tag::commandhandler-{StripTypeSuffix(type.Name).ToLowerInvariant()}[]");
+                stringBuilder.AppendLine($"=== {FormatTechnicalName(type.Name)}");
+                stringBuilder.AppendLine($"The \"`{FormatTechnicalName(type.Name).ToLower()}`\" command handler.");
+
+                if (!string.IsNullOrWhiteSpace(type.DocumentationComments?.Summary))
+                {
+                    stringBuilder.AppendLine(type.DocumentationComments.Summary);
+                    stringBuilder.AppendLine();
+                }
+
+                stringBuilder.AppendLine();
+                stringBuilder.AppendLine($".{FormatTechnicalName(type.Name)}");
+                stringBuilder.AppendLine($"[plantuml, commandhandler.{StripTypeSuffix(type.Name).ToLowerInvariant()}, png]");
+                stringBuilder.AppendLine("....");
+                stringBuilder.AppendLine($"include::{path}[]");
+                stringBuilder.AppendLine("....");
+                stringBuilder.AppendLine($"// end::commandhandler-{StripTypeSuffix(type.Name).ToLowerInvariant()}[]");
+            }
+
+            stringBuilder.AppendLine("// end::commandhandlers[]");
+        }
+
+        private void RenderDomainEvents(StringBuilder stringBuilder)
+        {
+            stringBuilder.AppendLine();
+            stringBuilder.AppendLine("// tag::domainevents[]");
+            stringBuilder.AppendLine("== Domain Events");
+            stringBuilder.AppendLine("Domain events in the eShop application.");
+
+            foreach (var type in this.types.Where(t => t.IsDomainEvent()).OrderBy(t => t.Name))
+            {
+                stringBuilder.AppendLine();
+                stringBuilder.AppendLine($"=== {FormatTechnicalName(type.Name)}");
+                stringBuilder.AppendLine($"The \"`{FormatTechnicalName(type.Name).ToLower()}`\" domain event.");
+                stringBuilder.AppendLine();
+
+                if (!string.IsNullOrWhiteSpace(type.DocumentationComments?.Summary))
+                {
+                    stringBuilder.AppendLine(type.DocumentationComments.Summary);
+                    stringBuilder.AppendLine();
+                }
+                
+                stringBuilder.AppendLine($".{type.Name.ToSentenceCase()} Fields");
+                stringBuilder.AppendLine("[%header%,width=\"75%\",cols=\"2h,3d\"]");
+                stringBuilder.AppendLine("|===");
+                stringBuilder.AppendLine("|Name|Type");
+
+                foreach (var property in type.Properties)
+                {
+                    stringBuilder.AppendLine($"|{property.Name}|{property.Type.ForDiagram()}");
+                }
+
+                stringBuilder.AppendLine("|===");
+            }
+
+            stringBuilder.AppendLine("// end::domainevents[]");
+        }
+
+        private void RenderDomainEventHandlers(StringBuilder stringBuilder)
+        {
+            stringBuilder.AppendLine();
+            stringBuilder.AppendLine("// tag::domaineventhandlers[]");
+            stringBuilder.AppendLine("== Domain Event Handlers");
+            stringBuilder.AppendLine("Domain event handlers in the eShop application.");
+
+            foreach (var (type, path) in this.eventHandlerFiles.Select(kv => (Type: this.types.FirstOrDefault(kv.Key), Path: kv.Value)).OrderBy(t => t.Type.Name))
+            {
+                stringBuilder.AppendLine();
+                stringBuilder.AppendLine($"// tag::domaineventhandler-{StripTypeSuffix(type.Name).ToLowerInvariant()}[]");
+                stringBuilder.AppendLine($"=== {FormatTechnicalName(type.Name)}");
+                stringBuilder.AppendLine($"The \"`{FormatTechnicalName(type.Name).ToLower()}`\" event handler.");
+
+                if (!string.IsNullOrWhiteSpace(type.DocumentationComments?.Summary))
+                {
+                    stringBuilder.AppendLine(type.DocumentationComments.Summary);
+                    stringBuilder.AppendLine();
+                }
+
+                stringBuilder.AppendLine();
+                stringBuilder.AppendLine($".{FormatTechnicalName(type.Name)}");
+                stringBuilder.AppendLine($"[plantuml, domaineventhandler.{StripTypeSuffix(type.Name).ToLowerInvariant()}, png]");
+                stringBuilder.AppendLine("....");
+                stringBuilder.AppendLine($"include::{path}[]");
+                stringBuilder.AppendLine("....");
+                stringBuilder.AppendLine($"// end::domaineventhandler-{StripTypeSuffix(type.Name).ToLowerInvariant()}[]");
+            }
+
+            stringBuilder.AppendLine("// end::domaineventhandlers[]");
+        }
+        private void RenderIntegrationEvents(StringBuilder stringBuilder)
+        {
+            stringBuilder.AppendLine();
+            stringBuilder.AppendLine("// tag::integrationevents[]");
+            stringBuilder.AppendLine("== Integration Events");
+            stringBuilder.AppendLine("Integration events in the eShop application.");
+
+            foreach (var type in this.types.Where(t => t.IsIntegrationEvent() && t.FullName.StartsWith("Ordering.API", StringComparison.Ordinal)).OrderBy(t => t.Name))
+            {
+                stringBuilder.AppendLine();
+                stringBuilder.AppendLine($"=== {FormatTechnicalName(type.Name)}");
+                stringBuilder.AppendLine($"The \"`{FormatTechnicalName(type.Name).ToLower()}`\" integration event.");
+                stringBuilder.AppendLine();
+
+                if (!string.IsNullOrWhiteSpace(type.DocumentationComments?.Summary))
+                {
+                    stringBuilder.AppendLine(type.DocumentationComments.Summary);
+                    stringBuilder.AppendLine();
+                }
+
+                stringBuilder.AppendLine($".{type.Name.ToSentenceCase()} Fields");
+                stringBuilder.AppendLine("[%header%,width=\"75%\",cols=\"2h,3d\"]");
+                stringBuilder.AppendLine("|===");
+                stringBuilder.AppendLine("|Name|Type");
+
+                foreach (var property in type.Properties)
+                {
+                    stringBuilder.AppendLine($"|{property.Name}|{property.Type.ForDiagram()}");
+                }
+
+                stringBuilder.AppendLine("|===");
+            }
+
+            stringBuilder.AppendLine("// end::integrationevents[]");
+        }
+
+        private static void RenderFileHeader(StringBuilder stringBuilder)
+        {
+            stringBuilder.AppendLine("= Generated documentation");
+            stringBuilder.AppendLine("Michaël Hompus <michael@hompus.nl>");
+            stringBuilder.AppendLine($"{Assembly.GetEntryAssembly().GetName().Version.ToString(3)}, {DateTime.Today:yyyy-MM-dd}");
+            stringBuilder.AppendLine(":toc: left");
+            stringBuilder.AppendLine(":toc-level: 2");
+            stringBuilder.AppendLine(":sectnums:");
+            stringBuilder.AppendLine(":icons: font");
+            stringBuilder.AppendLine();
+            stringBuilder.AppendLine("NOTE: This document has been automatically generated");
+            stringBuilder.AppendLine();
+            stringBuilder.AppendLine("The documentation is generated from the source code of https://github.com/dotnet-architecture/eShopOnContainers[eShopOnContainers^].");
+            stringBuilder.AppendLine();
+        }
+
+        private static string StripTypeSuffix(string name)
+        {
+            return replaceTypeSuffix.Replace(name, string.Empty);
+        }
+
+        private static string FormatTechnicalName(string name)
+        {
+            return StripTypeSuffix(name).ToSentenceCase();
+        }
+    }
+}
diff --git a/samples/LivingDocumentation.eShopOnContainers/Program.cs b/samples/LivingDocumentation.eShopOnContainers/Program.cs
index 413cf91..abe9afe 100644
--- a/samples/LivingDocumentation.eShopOnContainers/Program.cs
+++ b/samples/LivingDocumentation.eShopOnContainers/Program.cs
@@ -14,8 +14,7 @@ public static async Task Main(string[] args)
 
             var serializerSettings = new JsonSerializerSettings
             {
-                DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate,
-                Formatting = Formatting.None,
+                DefaultValueHandling = DefaultValueHandling.Include,
                 ContractResolver = new SkipEmptyCollectionsContractResolver(),
                 TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple,
                 TypeNameHandling = TypeNameHandling.Auto
diff --git a/samples/LivingDocumentation.eShopOnContainers/eShopOnContainerExtensions.cs b/samples/LivingDocumentation.eShopOnContainers/eShopOnContainerExtensions.cs
index 7f35bdf..fb4a39d 100644
--- a/samples/LivingDocumentation.eShopOnContainers/eShopOnContainerExtensions.cs
+++ b/samples/LivingDocumentation.eShopOnContainers/eShopOnContainerExtensions.cs
@@ -1,4 +1,4 @@
-using LivingDocumentation.Uml;
+using LivingDocumentation.Uml;
 using System;
 using System.Linq;
 using System.Text;
@@ -7,11 +7,11 @@ namespace LivingDocumentation.eShopOnContainers
 {
     public static class eShopOnContainersExtensions
     {
-        const string IntegrationEvent = "IntegrationEvent";
-        const string DomainEvent = "DomainEvent";
-        const string DomainEventHandler = "DomainEventHandler";
-        const string Command = "Command";
-        const string CommandHandler = "CommandHandler";
+        private const string IntegrationEvent = "IntegrationEvent";
+        private const string DomainEvent = "DomainEvent";
+        private const string DomainEventHandler = "DomainEventHandler";
+        private const string Command = "Command";
+        private const string CommandHandler = "CommandHandler";
 
         public static string ArrowColor(this string name)
         {
diff --git a/src/LivingDocumentation.Abstractions/IHaveDocumentationComments.cs b/src/LivingDocumentation.Abstractions/IHaveDocumentationComments.cs
new file mode 100644
index 0000000..66b0d19
--- /dev/null
+++ b/src/LivingDocumentation.Abstractions/IHaveDocumentationComments.cs
@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+
+namespace LivingDocumentation
+{
+    public interface IHaveDocumentationComments
+    {
+        string Example { get; }
+
+        IDictionary<string, string> Exceptions { get; }
+
+        IDictionary<string, string> Params { get; }
+
+        IDictionary<string, string> Permissions { get; }
+
+        string Remarks { get; }
+
+        string Returns { get; }
+
+        IDictionary<string, string> SeeAlsos { get; }
+
+        string Summary { get; }
+
+        IDictionary<string, string> TypeParams { get; }
+
+        string Value { get; }
+    }
+}
diff --git a/src/LivingDocumentation.Abstractions/IHaveMethodBody.cs b/src/LivingDocumentation.Abstractions/IHaveMethodBody.cs
index 8f5f485..2f3d1f8 100644
--- a/src/LivingDocumentation.Abstractions/IHaveMethodBody.cs
+++ b/src/LivingDocumentation.Abstractions/IHaveMethodBody.cs
@@ -4,6 +4,8 @@ namespace LivingDocumentation
 {
     public interface IHaveAMethodBody : IHaveModifiers
     {
+        IHaveDocumentationComments DocumentationComments { get; set; }
+
         string Name { get; }
 
         List<IParameterDescription> Parameters { get; }
diff --git a/src/LivingDocumentation.Abstractions/IMemberable.cs b/src/LivingDocumentation.Abstractions/IMemberable.cs
index cbfdac8..51cceb9 100644
--- a/src/LivingDocumentation.Abstractions/IMemberable.cs
+++ b/src/LivingDocumentation.Abstractions/IMemberable.cs
@@ -10,6 +10,6 @@ public interface IMemberable : IHaveModifiers
         [JsonProperty(Order = -3)]
         string Name { get; }
 
-        string Documentation { get; }
+        IHaveDocumentationComments DocumentationComments { get; }
     }
-}
\ No newline at end of file
+}
diff --git a/src/LivingDocumentation.Abstractions/MemberType.cs b/src/LivingDocumentation.Abstractions/MemberType.cs
index f90a9b2..fd8e7a1 100644
--- a/src/LivingDocumentation.Abstractions/MemberType.cs
+++ b/src/LivingDocumentation.Abstractions/MemberType.cs
@@ -6,6 +6,7 @@ public enum MemberType
         Method = 1,
         Property = 2,
         Constructor = 3,
-        EnumMember = 4
+        EnumMember = 4,
+        Event = 5
     }
-}
\ No newline at end of file
+}
diff --git a/src/LivingDocumentation.Analyzer/Analyzers/BranchingAnalyzer.cs b/src/LivingDocumentation.Analyzer/Analyzers/BranchingAnalyzer.cs
index da56601..6c99887 100644
--- a/src/LivingDocumentation.Analyzer/Analyzers/BranchingAnalyzer.cs
+++ b/src/LivingDocumentation.Analyzer/Analyzers/BranchingAnalyzer.cs
@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
@@ -21,14 +20,14 @@ public BranchingAnalyzer(in SemanticModel semanticModel, IList<Statement> statem
         public override void VisitIfStatement(IfStatementSyntax node)
         {
             var ifStatement = new If();
-            statements.Add(ifStatement);
+            this.statements.Add(ifStatement);
 
             var ifSection = new IfElseSection();
             ifStatement.Sections.Add(ifSection);
 
             ifSection.Condition = node.Condition.ToString();
 
-            var ifInvocationAnalyzer = new InvocationsAnalyzer(semanticModel, ifSection.Statements);
+            var ifInvocationAnalyzer = new InvocationsAnalyzer(this.semanticModel, ifSection.Statements);
             ifInvocationAnalyzer.Visit(node.Statement);
 
             var elseNode = node.Else;
@@ -37,7 +36,7 @@ public override void VisitIfStatement(IfStatementSyntax node)
                 var section = new IfElseSection();
                 ifStatement.Sections.Add(section);
 
-                var elseInvocationAnalyzer = new InvocationsAnalyzer(semanticModel, section.Statements);
+                var elseInvocationAnalyzer = new InvocationsAnalyzer(this.semanticModel, section.Statements);
                 elseInvocationAnalyzer.Visit(elseNode.Statement);
 
                 if (elseNode.Statement.IsKind(SyntaxKind.IfStatement))
@@ -57,7 +56,7 @@ public override void VisitIfStatement(IfStatementSyntax node)
         public override void VisitSwitchStatement(SwitchStatementSyntax node)
         {
             var switchStatement = new Switch();
-            statements.Add(switchStatement);
+            this.statements.Add(switchStatement);
 
             switchStatement.Expression = node.Expression.ToString();
 
@@ -68,7 +67,7 @@ public override void VisitSwitchStatement(SwitchStatementSyntax node)
 
                 switchSection.Labels.AddRange(section.Labels.Select(l => Label(l)));
 
-                var invocationAnalyzer = new InvocationsAnalyzer(semanticModel, switchSection.Statements);
+                var invocationAnalyzer = new InvocationsAnalyzer(this.semanticModel, switchSection.Statements);
                 invocationAnalyzer.Visit(section);
             }
         }
@@ -91,4 +90,4 @@ private static string Label(SwitchLabelSyntax label)
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/LivingDocumentation.Analyzer/Analyzers/InvocationsAnalyzer.cs b/src/LivingDocumentation.Analyzer/Analyzers/InvocationsAnalyzer.cs
index 01b1c50..d15378c 100644
--- a/src/LivingDocumentation.Analyzer/Analyzers/InvocationsAnalyzer.cs
+++ b/src/LivingDocumentation.Analyzer/Analyzers/InvocationsAnalyzer.cs
@@ -20,16 +20,16 @@ public InvocationsAnalyzer(in SemanticModel semanticModel, IList<Statement> stat
 
         public override void VisitObjectCreationExpression(ObjectCreationExpressionSyntax node)
         {
-            string containingType = semanticModel.GetTypeDisplayString(node);
+            string containingType = this.semanticModel.GetTypeDisplayString(node);
 
             var invocation = new InvocationDescription(containingType, node.Type.ToString());
-            statements.Add(invocation);
+            this.statements.Add(invocation);
 
             if (node.ArgumentList != null)
             {
                 foreach (var argument in node.ArgumentList.Arguments)
                 {
-                    var argumentDescription = new ArgumentDescription(semanticModel.GetTypeDisplayString(argument.Expression), argument.Expression.ToString());
+                    var argumentDescription = new ArgumentDescription(this.semanticModel.GetTypeDisplayString(argument.Expression), argument.Expression.ToString());
                     invocation.Arguments.Add(argumentDescription);
                 }
             }
@@ -38,7 +38,7 @@ public override void VisitObjectCreationExpression(ObjectCreationExpressionSynta
             {
                 foreach (var expression in node.Initializer.Expressions)
                 {
-                    var argumentDescription = new ArgumentDescription(semanticModel.GetTypeDisplayString(expression), expression.ToString());
+                    var argumentDescription = new ArgumentDescription(this.semanticModel.GetTypeDisplayString(expression), expression.ToString());
                     invocation.Arguments.Add(argumentDescription);
                 }
             }
@@ -48,41 +48,41 @@ public override void VisitObjectCreationExpression(ObjectCreationExpressionSynta
 
         public override void VisitSwitchStatement(SwitchStatementSyntax node)
         {
-            var branchingAnalyzer = new BranchingAnalyzer(semanticModel, statements);
+            var branchingAnalyzer = new BranchingAnalyzer(this.semanticModel, this.statements);
             branchingAnalyzer.Visit(node);
         }
 
         public override void VisitIfStatement(IfStatementSyntax node)
         {
-            var branchingAnalyzer = new BranchingAnalyzer(semanticModel, statements);
+            var branchingAnalyzer = new BranchingAnalyzer(this.semanticModel, this.statements);
             branchingAnalyzer.Visit(node);
         }
 
         public override void VisitForEachStatement(ForEachStatementSyntax node)
         {
-            var loopingAnalyzer = new LoopingAnalyzer(semanticModel, statements);
+            var loopingAnalyzer = new LoopingAnalyzer(this.semanticModel, this.statements);
             loopingAnalyzer.Visit(node);
         }
 
         public override void VisitInvocationExpression(InvocationExpressionSyntax node)
         {
-            if (Program.RuntimeOptions.VerboseOutput && semanticModel.GetTypeInfo(node).Type.Kind == SymbolKind.ErrorType)
+            if (Program.RuntimeOptions.VerboseOutput && this.semanticModel.GetTypeInfo(node).Type.Kind == SymbolKind.ErrorType)
             {
                 Console.WriteLine("WARN: Could not resolve type of invocation of the following block:");
                 Console.WriteLine(node.ToFullString());
                 return;
             }
 
-            if (semanticModel.GetConstantValue(node).HasValue && string.Equals((node.Expression as IdentifierNameSyntax)?.Identifier.ValueText, "nameof"))
+            if (this.semanticModel.GetConstantValue(node).HasValue && string.Equals((node.Expression as IdentifierNameSyntax)?.Identifier.ValueText, "nameof", StringComparison.Ordinal))
             {
                 // nameof is compiler sugar, and is actually a method we are not interrested in
                 return;
             }
 
-            string containingType = semanticModel.GetSymbolInfo(node.Expression).Symbol?.ContainingSymbol.ToDisplayString();
+            string containingType = this.semanticModel.GetSymbolInfo(node.Expression).Symbol?.ContainingSymbol.ToDisplayString();
             if (containingType == null)
             {
-                containingType = semanticModel.GetSymbolInfo(node.Expression).CandidateSymbols.FirstOrDefault()?.ContainingSymbol.ToDisplayString();
+                containingType = this.semanticModel.GetSymbolInfo(node.Expression).CandidateSymbols.FirstOrDefault()?.ContainingSymbol.ToDisplayString();
             }
 
             string methodName = string.Empty;
@@ -96,17 +96,20 @@ public override void VisitInvocationExpression(InvocationExpressionSyntax node)
                     methodName = i.Identifier.ValueText;
                     break;
             }
+            if (methodName == "Fire")
+            {
 
-            var invocation = new InvocationDescription(containingType, methodName);
-            statements.Add(invocation);
+            }
+                var invocation = new InvocationDescription(containingType, methodName);
+            this.statements.Add(invocation);
 
             foreach (var argument in node.ArgumentList.Arguments)
             {
-                var argumentDescription = new ArgumentDescription(semanticModel.GetTypeDisplayString(argument.Expression), argument.Expression.ToString());
+                var argumentDescription = new ArgumentDescription(this.semanticModel.GetTypeDisplayString(argument.Expression), argument.Expression.ToString());
                 invocation.Arguments.Add(argumentDescription);
             }
 
             base.VisitInvocationExpression(node);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/LivingDocumentation.Analyzer/Analyzers/LoopingAnalyzer.cs b/src/LivingDocumentation.Analyzer/Analyzers/LoopingAnalyzer.cs
index 736722f..a6267fb 100644
--- a/src/LivingDocumentation.Analyzer/Analyzers/LoopingAnalyzer.cs
+++ b/src/LivingDocumentation.Analyzer/Analyzers/LoopingAnalyzer.cs
@@ -1,6 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
+using System.Collections.Generic;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -21,12 +19,12 @@ public LoopingAnalyzer(in SemanticModel semanticModel, IList<Statement> statemen
         public override void VisitForEachStatement(ForEachStatementSyntax node)
         {
             var forEachStatement = new ForEach();
-            statements.Add(forEachStatement);
+            this.statements.Add(forEachStatement);
 
             forEachStatement.Expression = $"{node.Identifier.ToString()} in {node.Expression.ToString()}";
 
-            var invocationAnalyzer = new InvocationsAnalyzer(semanticModel, forEachStatement.Statements);
+            var invocationAnalyzer = new InvocationsAnalyzer(this.semanticModel, forEachStatement.Statements);
             invocationAnalyzer.Visit(node.Statement);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/LivingDocumentation.Analyzer/Analyzers/SourceAnalyzer.cs b/src/LivingDocumentation.Analyzer/Analyzers/SourceAnalyzer.cs
index f1b8523..d8de299 100644
--- a/src/LivingDocumentation.Analyzer/Analyzers/SourceAnalyzer.cs
+++ b/src/LivingDocumentation.Analyzer/Analyzers/SourceAnalyzer.cs
@@ -1,7 +1,6 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Xml.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -12,77 +11,95 @@ public class SourceAnalyzer : CSharpSyntaxWalker
     {
         private readonly SemanticModel semanticModel;
         private readonly IList<TypeDescription> types;
-        private readonly IReadOnlyList<AssemblyIdentity> referencedAssemblies;
 
         private TypeDescription currentType = null;
 
-        public SourceAnalyzer(in SemanticModel semanticModel, IList<TypeDescription> types, IReadOnlyList<AssemblyIdentity> referencedAssemblies)
+        public SourceAnalyzer(in SemanticModel semanticModel, IList<TypeDescription> types)
         {
             this.types = types;
             this.semanticModel = semanticModel;
-            this.referencedAssemblies = referencedAssemblies;
         }
 
         public override void VisitClassDeclaration(ClassDeclarationSyntax node)
         {
-            if (ProcessedEmbeddedType(node)) return;
+            if (this.ProcessedEmbeddedType(node)) return;
 
-            ExtractBaseTypeDeclaration(TypeType.Class, node);
+            this.ExtractBaseTypeDeclaration(TypeType.Class, node);
 
             base.VisitClassDeclaration(node);
         }
 
         public override void VisitEnumDeclaration(EnumDeclarationSyntax node)
         {
-            if (ProcessedEmbeddedType(node)) return;
+            if (this.ProcessedEmbeddedType(node)) return;
 
-            ExtractBaseTypeDeclaration(TypeType.Enum, node);
+            this.ExtractBaseTypeDeclaration(TypeType.Enum, node);
 
             base.VisitEnumDeclaration(node);
         }
 
         public override void VisitStructDeclaration(StructDeclarationSyntax node)
         {
-            if (ProcessedEmbeddedType(node)) return;
+            if (this.ProcessedEmbeddedType(node)) return;
 
-            ExtractBaseTypeDeclaration(TypeType.Struct, node);
+            this.ExtractBaseTypeDeclaration(TypeType.Struct, node);
 
             base.VisitStructDeclaration(node);
         }
 
         public override void VisitInterfaceDeclaration(InterfaceDeclarationSyntax node)
         {
-            if (ProcessedEmbeddedType(node)) return;
+            if (this.ProcessedEmbeddedType(node)) return;
 
-            ExtractBaseTypeDeclaration(TypeType.Interface, node);
+            this.ExtractBaseTypeDeclaration(TypeType.Interface, node);
 
             base.VisitInterfaceDeclaration(node);
         }
 
         public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
         {
-            var fieldDescription = new FieldDescription(semanticModel.GetTypeDisplayString(node.Declaration.Type), node.Declaration.Variables.First().Identifier.ValueText);
-            this.currentType.AddMember(fieldDescription);
+            foreach (var variable in node.Declaration.Variables)
+            {
+                var fieldDescription = new FieldDescription(this.semanticModel.GetTypeDisplayString(node.Declaration.Type), variable.Identifier.ValueText);
+                this.currentType.AddMember(fieldDescription);
 
-            fieldDescription.Modifiers |= ParseModifiers(node.Modifiers);
-            this.EnsureMemberDefaultAccessModifier(fieldDescription);
+                fieldDescription.Modifiers |= ParseModifiers(node.Modifiers);
+                this.EnsureMemberDefaultAccessModifier(fieldDescription);
 
-            fieldDescription.Initializer = node.Declaration.Variables.First().Initializer?.Value.ToString(); // Assumption: Field has only a single initializer
-            fieldDescription.Documentation = ExtractDocumentation(node);
+                fieldDescription.Initializer = variable.Initializer?.Value.ToString();
+                fieldDescription.DocumentationComments = this.ExtractDocumentation(variable);
+            }
 
             base.VisitFieldDeclaration(node);
         }
 
+        public override void VisitEventFieldDeclaration(EventFieldDeclarationSyntax node)
+        {
+            foreach (var variable in node.Declaration.Variables)
+            {
+                var fieldDescription = new EventDescription(this.semanticModel.GetTypeDisplayString(node.Declaration.Type), variable.Identifier.ValueText);
+                this.currentType.AddMember(fieldDescription);
+
+                fieldDescription.Modifiers |= ParseModifiers(node.Modifiers);
+                this.EnsureMemberDefaultAccessModifier(fieldDescription);
+
+                fieldDescription.Initializer = variable.Initializer?.Value.ToString();
+                fieldDescription.DocumentationComments = this.ExtractDocumentation(variable);
+            }
+
+            base.VisitEventFieldDeclaration(node);
+        }
+
         public override void VisitPropertyDeclaration(PropertyDeclarationSyntax node)
         {
-            var propertyDescription = new PropertyDescription(semanticModel.GetTypeDisplayString(node.Type), node.Identifier.ToString());
+            var propertyDescription = new PropertyDescription(this.semanticModel.GetTypeDisplayString(node.Type), node.Identifier.ToString());
             this.currentType.AddMember(propertyDescription);
 
             propertyDescription.Modifiers |= ParseModifiers(node.Modifiers);
             this.EnsureMemberDefaultAccessModifier(propertyDescription);
 
             propertyDescription.Initializer = node.Initializer?.Value.ToString();
-            propertyDescription.Documentation = ExtractDocumentation(node);
+            propertyDescription.DocumentationComments = this.ExtractDocumentation(node);
 
             base.VisitPropertyDeclaration(node);
         }
@@ -93,7 +110,7 @@ public override void VisitEnumMemberDeclaration(EnumMemberDeclarationSyntax node
             this.currentType.AddMember(enumMemberDescription);
 
             enumMemberDescription.Modifiers |= Modifier.Public;
-            enumMemberDescription.Documentation = ExtractDocumentation(node);
+            enumMemberDescription.DocumentationComments = this.ExtractDocumentation(node);
 
             base.VisitEnumMemberDeclaration(node);
         }
@@ -103,24 +120,24 @@ public override void VisitConstructorDeclaration(ConstructorDeclarationSyntax no
             var constructorDescription = new ConstructorDescription(node.Identifier.ToString());
             this.currentType.AddMember(constructorDescription);
 
-            ExtractBaseMethodDeclaration(node, constructorDescription);
+            this.ExtractBaseMethodDeclaration(node, constructorDescription);
 
             base.VisitConstructorDeclaration(node);
         }
 
         public override void VisitMethodDeclaration(MethodDeclarationSyntax node)
         {
-            var methodDescription = new MethodDescription(semanticModel.GetTypeInfo(node.ReturnType).Type.ToDisplayString(), node.Identifier.ToString());
+            var methodDescription = new MethodDescription(this.semanticModel.GetTypeInfo(node.ReturnType).Type.ToDisplayString(), node.Identifier.ToString());
             this.currentType.AddMember(methodDescription);
 
-            ExtractBaseMethodDeclaration(node, methodDescription);
+            this.ExtractBaseMethodDeclaration(node, methodDescription);
 
             base.VisitMethodDeclaration(node);
         }
 
         private void ExtractBaseTypeDeclaration(TypeType type, BaseTypeDeclarationSyntax node)
         {
-            this.currentType = new TypeDescription(type, semanticModel.GetDeclaredSymbol(node).ToDisplayString());
+            this.currentType = new TypeDescription(type, this.semanticModel.GetDeclaredSymbol(node).ToDisplayString());
             if (!this.types.Contains(this.currentType))
             {
                 this.types.Add(this.currentType);
@@ -128,17 +145,17 @@ private void ExtractBaseTypeDeclaration(TypeType type, BaseTypeDeclarationSyntax
 
             if (node.BaseList != null)
             {
-                this.currentType.BaseTypes.AddRange(node.BaseList.Types.Select(t => semanticModel.GetTypeDisplayString(t.Type)));
+                this.currentType.BaseTypes.AddRange(node.BaseList.Types.Select(t => this.semanticModel.GetTypeDisplayString(t.Type)));
             }
 
             this.currentType.Modifiers |= ParseModifiers(node.Modifiers);
             this.EnsureTypeDefaultAccessModifier(node);
 
-            this.currentType.Documentation = ExtractDocumentation(node);
+            this.currentType.DocumentationComments = this.ExtractDocumentation(node);
 
             if (node.AttributeLists != null)
             {
-                ExtractAttributes(node);
+                this.ExtractAttributes(node);
             }
         }
 
@@ -178,7 +195,7 @@ private bool ProcessedEmbeddedType(SyntaxNode node)
                 return false;
             }
 
-            var embeddedAnalyzer = new SourceAnalyzer(semanticModel, types, referencedAssemblies);
+            var embeddedAnalyzer = new SourceAnalyzer(this.semanticModel, this.types);
             embeddedAnalyzer.Visit(node);
 
             return true;
@@ -188,7 +205,7 @@ private void ExtractAttributes(BaseTypeDeclarationSyntax node)
         {
             foreach (var attribute in node.AttributeLists.SelectMany(a => a.Attributes))
             {
-                var attributeDescription = new AttributeDescription(semanticModel.GetTypeDisplayString(attribute), attribute.Name.ToString());
+                var attributeDescription = new AttributeDescription(this.semanticModel.GetTypeDisplayString(attribute), attribute.Name.ToString());
                 this.currentType.Attributes.Add(attributeDescription);
 
                 if (attribute.ArgumentList != null)
@@ -208,43 +225,33 @@ private void ExtractAttributes(BaseTypeDeclarationSyntax node)
                                 break;
                         }
 
-                        var argumentDescription = new AttributeArgumentDescription(argument.NameEquals?.Name.ToString() ?? argument.Expression?.ToString(), semanticModel.GetTypeDisplayString(argument.Expression), value);
+                        var argumentDescription = new AttributeArgumentDescription(argument.NameEquals?.Name.ToString() ?? argument.Expression?.ToString(), this.semanticModel.GetTypeDisplayString(argument.Expression), value);
                         attributeDescription.Arguments.Add(argumentDescription);
                     }
                 }
             }
         }
 
-        private string ExtractDocumentation(SyntaxNode node)
+        private DocumentationCommentsDescription ExtractDocumentation(SyntaxNode node)
         {
-            var documentationCommentXml = semanticModel.GetDeclaredSymbol(node)?.GetDocumentationCommentXml();
-
-            if (string.IsNullOrWhiteSpace(documentationCommentXml) || documentationCommentXml.StartsWith("<!--", StringComparison.Ordinal))
-            {
-                // No documenation or unparseable documentation
-                return null;
-            }
-
-            var element = XElement.Parse(documentationCommentXml);
-            var summary = element.Element("summary");
-
-            return summary?.Value.Trim();
+            return DocumentationCommentsDescription.Parse(this.semanticModel.GetDeclaredSymbol(node)?.GetDocumentationCommentXml());
         }
 
         private void ExtractBaseMethodDeclaration(BaseMethodDeclarationSyntax node, IHaveAMethodBody method)
         {
             method.Modifiers |= ParseModifiers(node.Modifiers);
+            method.DocumentationComments = this.ExtractDocumentation(node);
             this.EnsureMemberDefaultAccessModifier(method);
 
             foreach (var parameter in node.ParameterList.Parameters)
             {
-                var parameterDescription = new ParameterDescription(semanticModel.GetTypeDisplayString(parameter.Type), parameter.Identifier.ToString());
+                var parameterDescription = new ParameterDescription(this.semanticModel.GetTypeDisplayString(parameter.Type), parameter.Identifier.ToString());
                 method.Parameters.Add(parameterDescription);
 
                 parameterDescription.HasDefaultValue = parameter.Default != null;
             }
 
-            var invocationAnalyzer = new InvocationsAnalyzer(semanticModel, method.Statements);
+            var invocationAnalyzer = new InvocationsAnalyzer(this.semanticModel, method.Statements);
             invocationAnalyzer.Visit((SyntaxNode)node.Body ?? node.ExpressionBody);
         }
 
@@ -253,4 +260,4 @@ private static Modifier ParseModifiers(SyntaxTokenList modifiers)
             return (Modifier)modifiers.Select(m => Enum.TryParse(typeof(Modifier), m.ValueText, true, out var value) ? (int)value : 0).Sum();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/LivingDocumentation.Analyzer/LivingDocumentation.Analyzer.csproj b/src/LivingDocumentation.Analyzer/LivingDocumentation.Analyzer.csproj
index faa407f..1dc1a52 100644
--- a/src/LivingDocumentation.Analyzer/LivingDocumentation.Analyzer.csproj
+++ b/src/LivingDocumentation.Analyzer/LivingDocumentation.Analyzer.csproj
@@ -5,8 +5,8 @@
     <TargetFramework>netcoreapp2.1</TargetFramework>
     
     <RootNamespace>LivingDocumentation.Analyzer</RootNamespace>
-    <LangVersion>latest</LangVersion>
     <AssemblyName>LivingDocumentation.Analyzer</AssemblyName>
+    <LangVersion>latest</LangVersion>
 
     <PackAsTool>true</PackAsTool>
     <ToolCommandName>livingdoc-analyze</ToolCommandName>
@@ -29,6 +29,10 @@
   <ItemGroup>
     <PackageReference Include="Buildalyzer.Workspaces" Version="2.3.0" />
     <PackageReference Include="CommandLineParser" Version="2.5.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.4">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
   </ItemGroup>
 
diff --git a/src/LivingDocumentation.Analyzer/Options.cs b/src/LivingDocumentation.Analyzer/Options.cs
new file mode 100644
index 0000000..7f747cb
--- /dev/null
+++ b/src/LivingDocumentation.Analyzer/Options.cs
@@ -0,0 +1,40 @@
+using CommandLine;
+
+namespace LivingDocumentation
+{
+    public partial class Program
+    {
+        public class Options
+        {
+            [Option("solution", Required = true, HelpText = "The solution to analyze.")]
+            public string SolutionPath
+            {
+                get; set;
+            }
+
+            [Option("output", Required = true, HelpText = "The location of the output.")]
+            public string OutputPath
+            {
+                get; set;
+            }
+
+            [Option('v', "verbose", Default = false, HelpText = "Show warnings during compilation.")]
+            public bool VerboseOutput
+            {
+                get; set;
+            }
+
+            [Option('p', "pretty", Default = false, HelpText = "Store JSON output in indented formatting.")]
+            public bool PrettyPrint
+            {
+                get; set;
+            }
+
+            [Option('q', "quiet", Default = false, HelpText = "Don't output informational messages.")]
+            public bool Quiet
+            {
+                get; set;
+            }
+        }
+    }
+}
diff --git a/src/LivingDocumentation.Analyzer/Program.cs b/src/LivingDocumentation.Analyzer/Program.cs
index d407327..aceff40 100644
--- a/src/LivingDocumentation.Analyzer/Program.cs
+++ b/src/LivingDocumentation.Analyzer/Program.cs
@@ -12,23 +12,11 @@
 
 namespace LivingDocumentation
 {
-    public class Program
+    public static partial class Program
     {
         private static ParserResult<Options> ParsedResults;
 
-        public static Options RuntimeOptions { get; private set; }
-
-        public class Options
-        {
-            [Option("solution", Required = true, HelpText = "The solution to analyze.")]
-            public string SolutionPath { get; set; }
-
-            [Option("output", Required = true, HelpText = "The location of the output.")]
-            public string OutputPath { get; set; }
-
-            [Option('v', "verbose", Default = false, HelpText = "Show warnings during compilation.")]
-            public bool VerboseOutput { get; set; }
-        }
+        public static Options RuntimeOptions { get; private set; } = new Options();
 
         public static async Task Main(string[] args)
         {
@@ -37,7 +25,7 @@ public static async Task Main(string[] args)
             await ParsedResults.MapResult(
                 options => RunApplicationAsync(options),
                 errors => Task.FromResult(1)
-            );
+            ).ConfigureAwait(false);
         }
 
         private static async Task RunApplicationAsync(Options options)
@@ -47,21 +35,27 @@ private static async Task RunApplicationAsync(Options options)
             var types = new List<TypeDescription>();
 
             var stopwatch = Stopwatch.StartNew();
-            await AnalyzeSolutionAsync(types, options.SolutionPath);
+            await AnalyzeSolutionAsync(types, options.SolutionPath).ConfigureAwait(false);
             stopwatch.Stop();
 
             // Write analysis 
             var serializerSettings = new JsonSerializerSettings
             {
-                DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate,
+                DefaultValueHandling = DefaultValueHandling.Ignore,
+                NullValueHandling = NullValueHandling.Ignore,
                 ContractResolver = new SkipEmptyCollectionsContractResolver(),
-                TypeNameHandling = TypeNameHandling.Auto
+                TypeNameHandling = TypeNameHandling.Auto,
+                Formatting = options.PrettyPrint ? Formatting.Indented : Formatting.None
             };
 
             var result = JsonConvert.SerializeObject(types.OrderBy(t => t.FullName), serializerSettings);
 
-            await File.WriteAllTextAsync(options.OutputPath, result);
-            Console.WriteLine($"Living Documentation Analysis output generated in {stopwatch.ElapsedMilliseconds}ms at {options.OutputPath}");
+            await File.WriteAllTextAsync(options.OutputPath, result).ConfigureAwait(false);
+
+            if (!options.Quiet)
+            {
+                Console.WriteLine($"Living Documentation Analysis output generated in {stopwatch.ElapsedMilliseconds}ms at {options.OutputPath}");
+            }
         }
 
         private static async Task AnalyzeSolutionAsync(IList<TypeDescription> types, string solutionFile)
@@ -72,12 +66,11 @@ private static async Task AnalyzeSolutionAsync(IList<TypeDescription> types, str
 
             // Every project in the solution, except unit test projects
             var projects = workspace.CurrentSolution.Projects
-                .Where(p => !manager.Projects.First(mp => p.Id.Id == mp.Value.ProjectGuid).Value.ProjectFile.PackageReferences.Any(pr => pr.Name.Contains("Test")));
+                .Where(p => !manager.Projects.First(mp => p.Id.Id == mp.Value.ProjectGuid).Value.ProjectFile.PackageReferences.Any(pr => pr.Name.Contains("Test", StringComparison.Ordinal)));
 
             foreach (var project in projects)
             {
-                var compilation = await project.GetCompilationAsync();
-                var referencedAssemblies = compilation.ReferencedAssemblyNames.Where(a => !assembliesInSolution.Contains(a.Name)).ToList();
+                var compilation = await project.GetCompilationAsync().ConfigureAwait(false);
 
                 if (RuntimeOptions.VerboseOutput)
                 {
@@ -97,7 +90,7 @@ private static async Task AnalyzeSolutionAsync(IList<TypeDescription> types, str
                 {
                     var semanticModel = compilation.GetSemanticModel(syntaxTree, true);
 
-                    var visitor = new SourceAnalyzer(semanticModel, types, referencedAssemblies);
+                    var visitor = new SourceAnalyzer(semanticModel, types);
                     visitor.Visit(syntaxTree.GetRoot());
                 }
             }
diff --git a/src/LivingDocumentation.Descriptions/DocumentationComments/Attribute.cs b/src/LivingDocumentation.Descriptions/DocumentationComments/Attribute.cs
new file mode 100644
index 0000000..f306ab5
--- /dev/null
+++ b/src/LivingDocumentation.Descriptions/DocumentationComments/Attribute.cs
@@ -0,0 +1,10 @@
+namespace LivingDocumentation.DocumentationComments
+{
+    public class Attribute
+    {
+        public const string Name = "name";
+        public const string CRef = "cref";
+        public const string Type = "type";
+        public const string Start = "start";
+    }
+}
diff --git a/src/LivingDocumentation.Descriptions/DocumentationComments/Block.cs b/src/LivingDocumentation.Descriptions/DocumentationComments/Block.cs
new file mode 100644
index 0000000..e1b18d7
--- /dev/null
+++ b/src/LivingDocumentation.Descriptions/DocumentationComments/Block.cs
@@ -0,0 +1,9 @@
+namespace LivingDocumentation.DocumentationComments
+{
+    public class Block
+    {
+        public const string Code = "code";
+        public const string List = "list";
+        public const string Para = "para";
+    }
+}
diff --git a/src/LivingDocumentation.Descriptions/DocumentationComments/DocumentationCommentsDescription.cs b/src/LivingDocumentation.Descriptions/DocumentationComments/DocumentationCommentsDescription.cs
new file mode 100644
index 0000000..2d79d7f
--- /dev/null
+++ b/src/LivingDocumentation.Descriptions/DocumentationComments/DocumentationCommentsDescription.cs
@@ -0,0 +1,295 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml.Linq;
+using LivingDocumentation.DocumentationComments;
+using Attribute = LivingDocumentation.DocumentationComments.Attribute;
+
+namespace LivingDocumentation
+{
+    public partial class DocumentationCommentsDescription : IHaveDocumentationComments
+    {
+        private static readonly Regex InlineWhitespace = new Regex("(\\s{2,})", RegexOptions.ECMAScript);
+        private static readonly Regex MemberIdPrefix = new Regex("^[NTFPME\\!]:", RegexOptions.ECMAScript);
+
+        [DefaultValue("")]
+        public string Example { get; set; } = string.Empty;
+
+        [DefaultValue("")]
+        public string Remarks { get; set; } = string.Empty;
+
+        [DefaultValue("")]
+        public string Returns { get; set; } = string.Empty;
+
+        [DefaultValue("")]
+        public string Summary { get; set; } = string.Empty;
+
+        [DefaultValue("")]
+        public string Value { get; set; } = string.Empty;
+
+        public IDictionary<string, string> Exceptions { get; set; } = new Dictionary<string, string>();
+
+        public IDictionary<string, string> Permissions { get; set; } = new Dictionary<string, string>();
+
+        public IDictionary<string, string> Params { get; set; } = new Dictionary<string, string>();
+
+        public IDictionary<string, string> SeeAlsos { get; set; } = new Dictionary<string, string>();
+
+        public IDictionary<string, string> TypeParams { get; set; } = new Dictionary<string, string>();
+
+        public static DocumentationCommentsDescription Parse(string documentationCommentXml)
+        {
+            if (string.IsNullOrWhiteSpace(documentationCommentXml) || documentationCommentXml.StartsWith("<!--", StringComparison.Ordinal))
+            {
+                // No documenation or unparseable documentation
+                return null;
+            }
+
+            var element = XElement.Parse(documentationCommentXml);
+
+            var documentation = new DocumentationCommentsDescription();
+
+            documentation.Example = documentation.ParseSection(element.Element(Section.Example));
+            documentation.Remarks = documentation.ParseSection(element.Element(Section.Remarks));
+            documentation.Returns = documentation.ParseSection(element.Element(Section.Returns));
+            documentation.Summary = documentation.ParseSection(element.Element(Section.Summary), true);
+            documentation.Value = documentation.ParseSection(element.Element(Section.Value));
+
+            documentation.ParseSection(element.Elements(Section.Exception));
+            documentation.ParseSection(element.Elements(Section.Param));
+            documentation.ParseSection(element.Elements(Section.Permission));
+            documentation.ParseSection(element.Elements(Section.SeeAlso));
+            documentation.ParseSection(element.Elements(Section.TypeParam));
+
+            return documentation;
+        }
+
+        private void ParseSection(IEnumerable<XElement> sections)
+        {
+            if (sections == null || !sections.Any())
+            {
+                return;
+            }
+
+            foreach (var section in sections)
+            {
+                switch (section.Name.LocalName)
+                {
+                    case Section.Exception when !string.IsNullOrWhiteSpace(section.Attribute(Attribute.CRef).Value):
+                        this.Exceptions.Add(StripIDPrefix(section.Attribute(Attribute.CRef).Value), this.ParseSection(section));
+                        break;
+
+                    case Section.Param when !string.IsNullOrWhiteSpace(section.Attribute(Attribute.Name).Value):
+                        this.Params.Add(StripIDPrefix(section.Attribute(Attribute.Name).Value), this.ParseSection(section));
+                        break;
+
+                    case Section.Permission when !string.IsNullOrWhiteSpace(section.Attribute(Attribute.CRef).Value):
+                        this.Permissions.Add(StripIDPrefix(section.Attribute(Attribute.CRef).Value), this.ParseSection(section));
+                        break;
+
+                    case Section.SeeAlso when !string.IsNullOrWhiteSpace(section.Attribute(Attribute.CRef).Value):
+                        this.ProcessSeeAlsoTag(section, false);
+                        break;
+
+                    case Section.TypeParam when !string.IsNullOrWhiteSpace(section.Attribute(Attribute.Name).Value):
+                        this.TypeParams.Add(StripIDPrefix(section.Attribute(Attribute.Name).Value), this.ParseSection(section));
+                        break;
+                }
+            }
+        }
+
+        private string ParseSection(XElement section, bool removeNewLines = false)
+        {
+            if (section == null || section.IsEmpty)
+            {
+                return string.Empty;
+            }
+
+            var contents = new StringBuilder();
+
+            foreach (var node in section.Nodes())
+            {
+                switch (node)
+                {
+                    case XText text:
+                        ProcessInlineContent(contents, text.Value, removeNewLines);
+                        break;
+
+                    case XElement element when element.Name == Block.Code || element.Name == Block.Para:
+                        this.ProcessBlockContent(contents, element);
+                        break;
+
+                    case XElement element when element.Name == Block.List:
+                        this.ProcessListContent(contents, element);
+                        break;
+
+                    case XElement element when element.Name == Inline.C:
+                        ProcessInlineContent(contents, element.Value, removeNewLines);
+                        break;
+
+                    case XElement element when (element.Name == Inline.ParamRef || element.Name == Inline.TypeParamRef) && element.Attribute(Attribute.Name) != null:
+                        ProcessInlineContent(contents, StripIDPrefix(element.Attribute(Attribute.Name).Value), removeNewLines);
+                        break;
+
+                    case XElement element when element.Name == Inline.See:
+                        ProcessInlineContent(contents, element.IsEmpty ? StripIDPrefix(element.Attribute(Attribute.CRef)?.Value) : element.Value, removeNewLines);
+                        break;
+
+                    case XElement element when element.Name == Section.SeeAlso:
+                        this.ProcessSeeAlsoTag(element, removeNewLines);
+                        break;
+
+                    case XElement element when !element.IsEmpty:
+                        ProcessInlineContent(contents, element.Value, removeNewLines);
+                        break;
+                }
+            }
+
+            return contents.ToString().Trim();
+        }
+
+        private void ProcessListContent(StringBuilder contents, XElement element)
+        {
+            var listType = element.Attribute(Attribute.Type)?.Value;
+            switch (listType)
+            {
+                case ListType.Bullet:
+                    foreach (var item in element.Elements(List.Item))
+                    {
+                        var term = this.ParseSection(item.Element(List.Term));
+                        var description = this.ParseSection(item.Element(List.Description));
+
+                        contents.Append("* ");
+
+                        if (!string.IsNullOrEmpty(term))
+                        {
+                            contents.Append(term);
+                            contents.Append(" - ");
+                        }
+
+                        if (!string.IsNullOrEmpty(description))
+                        {
+                            contents.Append(description);
+                        }
+
+                        if (string.IsNullOrEmpty(term) && string.IsNullOrEmpty(description))
+                        {
+                            contents.Append(item.Value.Trim());
+                        }
+
+                        contents.Append('\n');
+
+                    }
+                    break;
+
+                case ListType.Number:
+                    if (!int.TryParse(element.Attribute(Attribute.Start)?.Value.Trim() ?? "1", out var startIndex))
+                    {
+                        startIndex = 1;
+                    }
+
+                    foreach (var item in element.Elements(List.Item))
+                    {
+                        var term = this.ParseSection(item.Element(List.Term));
+                        var description = this.ParseSection(item.Element(List.Description));
+
+                        contents.Append(startIndex);
+                        contents.Append(". ");
+
+                        if (!string.IsNullOrEmpty(term))
+                        {
+                            contents.Append(term);
+                            contents.Append(" - ");
+                        }
+
+                        if (!string.IsNullOrEmpty(description))
+                        {
+                            contents.Append(description);
+                        }
+
+                        if (string.IsNullOrEmpty(term) && string.IsNullOrEmpty(description))
+                        {
+                            contents.Append(item.Value.Trim());
+                        }
+
+                        contents.Append('\n');
+
+                        startIndex++;
+                    }
+                    break;
+
+                case ListType.Definition:
+                    foreach (var item in element.Elements(List.Item))
+                    {
+                        var term = this.ParseSection(item.Element(List.Term));
+                        var description = this.ParseSection(item.Element(List.Description));
+
+                        contents.Append(term);
+                        contents.Append('\n');
+                        contents.Append(new string(' ', 4));
+                        contents.Append(description);
+                        contents.Append('\n');
+                    }
+                    break;
+
+                default:
+                    contents.Append(string.Join(" ", element.Descendants().Select(e => this.ParseSection(e))));
+                    break;
+            }
+        }
+
+        private static void ProcessInlineContent(StringBuilder stringBuilder, string text, bool removeNewLines)
+        {
+            if (stringBuilder.Length > 0 && stringBuilder[stringBuilder.Length - 1] != ' ' && stringBuilder[stringBuilder.Length - 1] != '\n')
+            {
+                stringBuilder.Append(' ');
+            }
+
+            if (removeNewLines)
+            {
+                stringBuilder.Append(InlineWhitespace.Replace(text, " ").Trim());
+            }
+            else
+            {
+                stringBuilder.Append(string.Join("\n", text.Split('\n').Select(t => t.Trim())));
+            }
+        }
+
+        private void ProcessBlockContent(StringBuilder stringBuilder, XElement element)
+        {
+            if (stringBuilder.Length > 0 && stringBuilder[stringBuilder.Length - 1] != '\n')
+            {
+                stringBuilder.Append('\n');
+            }
+
+            stringBuilder.Append(this.ParseSection(element));
+            stringBuilder.Append('\n');
+        }
+
+        private void ProcessSeeAlsoTag(XElement element, bool removeNewLines)
+        {
+            var key = StripIDPrefix(element.Attribute(Attribute.CRef).Value);
+
+            var contents = new StringBuilder();
+
+            ProcessInlineContent(contents, element.Value, removeNewLines);
+
+            var value = contents.ToString().Trim();
+
+            this.SeeAlsos.Add(key, !string.IsNullOrEmpty(value) ? value : key);
+        }
+
+        private static string StripIDPrefix(string value)
+        {
+            if (string.IsNullOrWhiteSpace(value))
+            {
+                return string.Empty;
+            }
+
+            return MemberIdPrefix.Replace(value, string.Empty);
+        }
+    }
+}
diff --git a/src/LivingDocumentation.Descriptions/DocumentationComments/Inline.cs b/src/LivingDocumentation.Descriptions/DocumentationComments/Inline.cs
new file mode 100644
index 0000000..bcdbebc
--- /dev/null
+++ b/src/LivingDocumentation.Descriptions/DocumentationComments/Inline.cs
@@ -0,0 +1,10 @@
+namespace LivingDocumentation.DocumentationComments
+{
+    public class Inline
+    {
+        public const string C = "c";
+        public const string ParamRef = "paramref";
+        public const string TypeParamRef = "typeparamref";
+        public const string See = "see";
+    }
+}
diff --git a/src/LivingDocumentation.Descriptions/DocumentationComments/List.cs b/src/LivingDocumentation.Descriptions/DocumentationComments/List.cs
new file mode 100644
index 0000000..bfa8e7b
--- /dev/null
+++ b/src/LivingDocumentation.Descriptions/DocumentationComments/List.cs
@@ -0,0 +1,10 @@
+namespace LivingDocumentation.DocumentationComments
+{
+    public class List
+    {
+        public const string Item = "item";
+        public const string Term = "term";
+        public const string Description = "description";
+        public const string ListHeader = "listHeader";
+    }
+}
diff --git a/src/LivingDocumentation.Descriptions/DocumentationComments/ListType.cs b/src/LivingDocumentation.Descriptions/DocumentationComments/ListType.cs
new file mode 100644
index 0000000..8717140
--- /dev/null
+++ b/src/LivingDocumentation.Descriptions/DocumentationComments/ListType.cs
@@ -0,0 +1,10 @@
+namespace LivingDocumentation.DocumentationComments
+{
+    public class ListType
+    {
+        public const string Bullet = "bullet";
+        public const string Number = "number";
+        public const string Definition = "definition";
+        public const string Table = "table";
+    }
+}
diff --git a/src/LivingDocumentation.Descriptions/DocumentationComments/Section.cs b/src/LivingDocumentation.Descriptions/DocumentationComments/Section.cs
new file mode 100644
index 0000000..ff38774
--- /dev/null
+++ b/src/LivingDocumentation.Descriptions/DocumentationComments/Section.cs
@@ -0,0 +1,16 @@
+namespace LivingDocumentation.DocumentationComments
+{
+    public class Section
+    {
+        public const string Example = "example";
+        public const string Exception = "exception";
+        public const string Param = "param";
+        public const string Permission = "permission";
+        public const string Remarks = "remarks";
+        public const string Returns = "returns";
+        public const string SeeAlso = "seealso";
+        public const string Summary = "summary";
+        public const string TypeParam = "typeparam";
+        public const string Value = "value";
+    }
+}
diff --git a/src/LivingDocumentation.Descriptions/EventDescription.cs b/src/LivingDocumentation.Descriptions/EventDescription.cs
new file mode 100644
index 0000000..d40ddc4
--- /dev/null
+++ b/src/LivingDocumentation.Descriptions/EventDescription.cs
@@ -0,0 +1,24 @@
+using Newtonsoft.Json;
+using System.Diagnostics;
+
+namespace LivingDocumentation
+{
+    [DebuggerDisplay("Event {Type,nq} {Name,nq}")]
+    public class EventDescription : MemberDescription
+    {
+        public string Type { get; }
+
+        public string Initializer { get; set; }
+
+        [JsonIgnore]
+        public bool HasInitializer => this.Initializer != null;
+
+        public override MemberType MemberType => MemberType.Event;
+
+        public EventDescription(string type, string name)
+            : base(name)
+        {
+            this.Type = type;
+        }
+    }
+}
diff --git a/src/LivingDocumentation.Descriptions/LivingDocumentation.Descriptions.csproj b/src/LivingDocumentation.Descriptions/LivingDocumentation.Descriptions.csproj
index 6b40c5a..b415959 100644
--- a/src/LivingDocumentation.Descriptions/LivingDocumentation.Descriptions.csproj
+++ b/src/LivingDocumentation.Descriptions/LivingDocumentation.Descriptions.csproj
@@ -3,6 +3,7 @@
   <PropertyGroup>
     <TargetFramework>netstandard1.0</TargetFramework>
     <RootNamespace>LivingDocumentation</RootNamespace>
+    <LangVersion>latest</LangVersion>
     
     <Version>0.1.0</Version>
     <Authors>Michaël Hompus</Authors>
diff --git a/src/LivingDocumentation.Descriptions/MemberDescription.cs b/src/LivingDocumentation.Descriptions/MemberDescription.cs
index e2cd27f..23baa28 100644
--- a/src/LivingDocumentation.Descriptions/MemberDescription.cs
+++ b/src/LivingDocumentation.Descriptions/MemberDescription.cs
@@ -14,11 +14,11 @@ public abstract class MemberDescription : IMemberable
 
         public bool IsInherited { get; internal set; } = false;
 
-        public string Documentation { get; set; }
+        public IHaveDocumentationComments DocumentationComments { get; set; }
 
         public MemberDescription(string name)
         {
             this.Name = name;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/LivingDocumentation.Descriptions/PropertyDescription.cs b/src/LivingDocumentation.Descriptions/PropertyDescription.cs
index 0e71bd0..830f589 100644
--- a/src/LivingDocumentation.Descriptions/PropertyDescription.cs
+++ b/src/LivingDocumentation.Descriptions/PropertyDescription.cs
@@ -1,5 +1,4 @@
-using Newtonsoft.Json;
-using System.ComponentModel;
+using Newtonsoft.Json;
 using System.Diagnostics;
 
 namespace LivingDocumentation
@@ -12,7 +11,7 @@ public class PropertyDescription : MemberDescription
         public string Initializer { get; set; }
         
         [JsonIgnore]
-        public bool HasInitializer => this.Initializer != null;
+        public bool HasInitializer => !string.IsNullOrWhiteSpace(this.Initializer);
 
         public override MemberType MemberType => MemberType.Property;
 
diff --git a/src/LivingDocumentation.Descriptions/TypeDescription.cs b/src/LivingDocumentation.Descriptions/TypeDescription.cs
index 90ea8ca..22d0734 100644
--- a/src/LivingDocumentation.Descriptions/TypeDescription.cs
+++ b/src/LivingDocumentation.Descriptions/TypeDescription.cs
@@ -1,4 +1,4 @@
-using Newtonsoft.Json;
+using Newtonsoft.Json;
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
@@ -10,21 +10,24 @@ namespace LivingDocumentation
     public class TypeDescription : IHaveModifiers
     {
 
-        [JsonProperty(Order = 1, PropertyName = nameof(Fields), DefaultValueHandling = DefaultValueHandling.Include)]
+        [JsonProperty(Order = 1, PropertyName = nameof(Fields))]
         private readonly List<FieldDescription> fields = new List<FieldDescription>();
 
-        [JsonProperty(Order = 2, PropertyName = nameof(Constructors), DefaultValueHandling = DefaultValueHandling.Include)]
+        [JsonProperty(Order = 2, PropertyName = nameof(Constructors))]
         private readonly List<ConstructorDescription> constructors = new List<ConstructorDescription>();
 
-        [JsonProperty(Order = 3, PropertyName = nameof(Properties), DefaultValueHandling = DefaultValueHandling.Include)]
+        [JsonProperty(Order = 3, PropertyName = nameof(Properties))]
         private readonly List<PropertyDescription> properties = new List<PropertyDescription>();
 
-        [JsonProperty(Order = 4, PropertyName = nameof(Methods), DefaultValueHandling = DefaultValueHandling.Include)]
+        [JsonProperty(Order = 4, PropertyName = nameof(Methods))]
         private readonly List<MethodDescription> methods = new List<MethodDescription>();
 
-        [JsonProperty(Order = 5, PropertyName = nameof(EnumMembers), DefaultValueHandling = DefaultValueHandling.Include)]
+        [JsonProperty(Order = 5, PropertyName = nameof(EnumMembers))]
         private readonly List<EnumMemberDescription> enumMembers = new List<EnumMemberDescription>();
 
+        [JsonProperty(Order = 6, PropertyName = nameof(Events))]
+        private readonly List<EventDescription> events = new List<EventDescription>();
+
         public TypeDescription(TypeType type, string fullName)
         {
             this.Type = type;
@@ -35,7 +38,7 @@ public TypeDescription(TypeType type, string fullName)
 
         public string FullName { get; }
 
-        public string Documentation { get; set; }
+        public DocumentationCommentsDescription DocumentationComments { get; set; }
 
         public List<string> BaseTypes { get; } = new List<string>();
 
@@ -59,6 +62,9 @@ public TypeDescription(TypeType type, string fullName)
         [JsonIgnore]
         public IReadOnlyList<MethodDescription> Methods => this.methods;
 
+        [JsonIgnore]
+        public IReadOnlyList<EventDescription> Events => this.events;
+
         [JsonIgnore]
         public IReadOnlyList<FieldDescription> Fields => this.fields;
 
@@ -85,8 +91,12 @@ public void AddMember(MemberDescription member)
                     this.methods.Add(m);
                     break;
 
-                case EnumMemberDescription e:
-                    this.enumMembers.Add(e);
+                case EnumMemberDescription em:
+                    this.enumMembers.Add(em);
+                    break;
+
+                case EventDescription e:
+                    this.events.Add(e);
                     break;
 
                 default:
diff --git a/src/LivingDocumentation.Render/StringExtensions.cs b/src/LivingDocumentation.Render/StringExtensions.cs
index 6e70d3c..f1fd0f1 100644
--- a/src/LivingDocumentation.Render/StringExtensions.cs
+++ b/src/LivingDocumentation.Render/StringExtensions.cs
@@ -9,7 +9,11 @@ public static class StringExtensions
     {
         public static bool IsEnumerable(this string type)
         {
-            if (type.StartsWith("System.Collections.Generic.", StringComparison.Ordinal))
+            if (!type.StartsWith("System.Collections.", StringComparison.Ordinal))
+            {
+                return false;
+            }
+            else if (type.StartsWith("System.Collections.Generic.", StringComparison.Ordinal))
             {
                 return !type.Contains("Enumerator") && !type.Contains("Compar") && !type.Contains("Exception");
             }
@@ -17,14 +21,8 @@ public static bool IsEnumerable(this string type)
             {
                 return !type.Contains("Partition");
             }
-            else if (type.StartsWith("System.Collections.", StringComparison.Ordinal))
-            {
-                return !type.Contains("Enumerator") && !type.Contains("Compar") && !type.Contains("Structural") && !type.Contains("Provider");
-            }
-            else
-            {
-                return false;
-            }
+
+            return !type.Contains("Enumerator") && !type.Contains("Compar") && !type.Contains("Structural") && !type.Contains("Provider");
         }
 
         public static bool IsGeneric(this string type)
@@ -34,29 +32,27 @@ public static bool IsGeneric(this string type)
 
         public static IReadOnlyList<string> GenericTypes(this string type)
         {
-            if (type.IsGeneric())
+            if (!type.IsGeneric())
             {
-                var typeParts = type.Substring(type.IndexOf('<') + 1, type.Length - type.IndexOf('<') - 2).Split(',');
-                var types = new List<string>();
+                return new List<string>(0);
+            }
 
-                foreach (var part in typeParts)
-                {
-                    if (part.IndexOf('>') > -1 && types.Count > 0 && types.Last().ToCharArray().Count(c => c == '<') > types.Last().ToCharArray().Count(c => c == '>'))
-                    {
-                        types[types.Count - 1] = types[types.Count - 1] + "," + part;
-                    }
-                    else
-                    {
-                        types.Add(part);
-                    }
-                }
+            var typeParts = type.Substring(type.IndexOf('<') + 1, type.Length - type.IndexOf('<') - 2).Split(',');
+            var types = new List<string>();
 
-                return types;
-            }
-            else
+            foreach (var part in typeParts)
             {
-                return new List<string>(0);
+                if (part.IndexOf('>') > -1 && types.Count > 0 && types.Last().ToCharArray().Count(c => c == '<') > types.Last().ToCharArray().Count(c => c == '>'))
+                {
+                    types[types.Count - 1] = types[types.Count - 1] + "," + part.Trim();
+                }
+                else
+                {
+                    types.Add(part.Trim());
+                }
             }
+
+            return types;
         }
 
         public static string ForDiagram(this string type)
@@ -101,4 +97,4 @@ public static string ToSentenceCase(this string input)
             return stringBuilder.ToString();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/ClassModifierTests.cs b/tests/LivingDocumentation.Analyzer.Tests/ClassModifierTests.cs
index 706ef4d..d5fc556 100644
--- a/tests/LivingDocumentation.Analyzer.Tests/ClassModifierTests.cs
+++ b/tests/LivingDocumentation.Analyzer.Tests/ClassModifierTests.cs
@@ -1,9 +1,5 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.Collections.Generic;
-using System.Linq;
 using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace LivingDocumentation.Analyzer.Tests
 {
@@ -21,7 +17,7 @@ class Test
             ";
 
             // Act
-            var types = VisitSyntaxTree(source);
+            var types = TestHelper.VisitSyntaxTree(source);
 
             // Assert
             types[0].Modifiers.Should().Be(Modifier.Internal);
@@ -38,7 +34,7 @@ public class Test
             ";
 
             // Act
-            var types = VisitSyntaxTree(source);
+            var types = TestHelper.VisitSyntaxTree(source);
 
             // Assert
             types[0].Modifiers.Should().Be(Modifier.Public);
@@ -55,7 +51,7 @@ static class Test
             ";
 
             // Act
-            var types = VisitSyntaxTree(source);
+            var types = TestHelper.VisitSyntaxTree(source);
 
             // Assert
             types[0].Modifiers.Should().HaveFlag(Modifier.Static);
@@ -75,7 +71,7 @@ class NestedTest
             ";
 
             // Act
-            var types = VisitSyntaxTree(source);
+            var types = TestHelper.VisitSyntaxTree(source);
 
             // Assert
             types[1].Modifiers.Should().Be(Modifier.Private);
@@ -95,33 +91,10 @@ public class NestedTest
             ";
 
             // Act
-            var types = VisitSyntaxTree(source);
+            var types = TestHelper.VisitSyntaxTree(source);
 
             // Assert
             types[1].Modifiers.Should().Be(Modifier.Public);
         }
-
-        private static IReadOnlyList<TypeDescription> VisitSyntaxTree(string source)
-        {
-            source.Should().NotBeNullOrWhiteSpace("without source code there is nothing to test");
-
-            var syntaxTree = CSharpSyntaxTree.ParseText(source.Trim());
-            var compilation = CSharpCompilation.Create("Test")
-                                               .WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
-                                               .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
-                                               .AddSyntaxTrees(syntaxTree);
-
-            var diagnostics = compilation.GetDiagnostics();
-            diagnostics.Should().HaveCount(0, "there shoudn't be any compile errors");
-
-            var semanticModel = compilation.GetSemanticModel(syntaxTree, true);
-
-            var types = new List<TypeDescription>();
-
-            var visitor = new SourceAnalyzer(semanticModel, types, Enumerable.Empty<AssemblyIdentity>().ToList());
-            visitor.Visit(syntaxTree.GetRoot());
-
-            return types;
-        }
     }
 }
diff --git a/tests/LivingDocumentation.Analyzer.Tests/Descriptions/ArgumentDescriptionTests.cs b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/ArgumentDescriptionTests.cs
new file mode 100644
index 0000000..e424148
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/ArgumentDescriptionTests.cs
@@ -0,0 +1,25 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    [TestClass]
+    public class ArgumentDescriptionTests
+    {
+        [TestMethod]
+        public void ArgumentDescription_Constructor_Should_SetType()
+        {
+            var description = new ArgumentDescription("System.String", null);
+
+            description.Type.Should().Be("System.String");
+        }
+
+        [TestMethod]
+        public void ArgumentDescription_Constructor_Should_SetName()
+        {
+            var description = new ArgumentDescription(null, "TestText");
+
+            description.Text.Should().Be("TestText");
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/Descriptions/AttributeArgumentDescriptionTests.cs b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/AttributeArgumentDescriptionTests.cs
new file mode 100644
index 0000000..7729b91
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/AttributeArgumentDescriptionTests.cs
@@ -0,0 +1,33 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    [TestClass]
+    public class AttributeArgumentDescriptionTests
+    {
+        [TestMethod]
+        public void AttributeArgumentDescription_Constructor_Should_SetType()
+        {
+            var description = new AttributeArgumentDescription(null, "System.String", null);
+
+            description.Type.Should().Be("System.String");
+        }
+
+        [TestMethod]
+        public void AttributeArgumentDescription_Constructor_Should_SetName()
+        {
+            var description = new AttributeArgumentDescription("TestArgument", null, null);
+
+            description.Name.Should().Be("TestArgument");
+        }
+
+        [TestMethod]
+        public void AttributeArgumentDescription_Constructor_Should_SetValue()
+        {
+            var description = new AttributeArgumentDescription(null, null, "TestValue");
+
+            description.Value.Should().Be("TestValue");
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/Descriptions/AttributeDescriptionTests.cs b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/AttributeDescriptionTests.cs
new file mode 100644
index 0000000..59a0a4b
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/AttributeDescriptionTests.cs
@@ -0,0 +1,33 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    [TestClass]
+    public class AttributeDescriptionTests
+    {
+        [TestMethod]
+        public void AttributeDescription_Constructor_Should_SetType()
+        {
+            var description = new AttributeDescription("System.String", null);
+
+            description.Type.Should().Be("System.String");
+        }
+
+        [TestMethod]
+        public void AttributeDescription_Constructor_Should_SetName()
+        {
+            var description = new AttributeDescription(null, "TestParameter");
+
+            description.Name.Should().Be("TestParameter");
+        }
+
+        [TestMethod]
+        public void AttributeDescription_Arguments_Should_BeEmpty()
+        {
+            var description = new AttributeDescription(null, null);
+
+            description.Arguments.Should().BeEmpty();
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/Descriptions/ConstructureDescriptionTests.cs b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/ConstructureDescriptionTests.cs
new file mode 100644
index 0000000..3bc545f
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/ConstructureDescriptionTests.cs
@@ -0,0 +1,33 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    [TestClass]
+    public class ConstructorDescriptionTests
+    {
+        [TestMethod]
+        public void ConstructorDescription_Constructor_Should_SetName()
+        {
+            var description = new ConstructorDescription("TestConstructor");
+
+            description.Name.Should().Be("TestConstructor");
+        }
+
+        [TestMethod]
+        public void ConstructorDescription_MemberType_Should_BeConstructor()
+        {
+            var description = new ConstructorDescription(null);
+
+            description.MemberType.Should().Be(MemberType.Constructor);
+        }
+
+        [TestMethod]
+        public void ConstructorDescription_Parameters_Should_BeEmpty()
+        {
+            var description = new ConstructorDescription(null);
+
+            description.Parameters.Should().BeEmpty();
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/Descriptions/EnumMemberDescriptionTests.cs b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/EnumMemberDescriptionTests.cs
new file mode 100644
index 0000000..07e9304
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/EnumMemberDescriptionTests.cs
@@ -0,0 +1,33 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    [TestClass]
+    public class EnumMemberDescriptionTests
+    {
+        [TestMethod]
+        public void EnumMemberDescription_Constructor_Should_SetType()
+        {
+            var description = new EnumMemberDescription(null, "TestValue");
+
+            description.Value.Should().Be("TestValue");
+        }
+
+        [TestMethod]
+        public void EnumMemberDescription_Constructor_Should_SetName()
+        {
+            var description = new EnumMemberDescription("TestEnumMember", null);
+
+            description.Name.Should().Be("TestEnumMember");
+        }
+
+        [TestMethod]
+        public void EnumMemberDescription_MemberType_Should_BeEnumMember()
+        {
+            var description = new EnumMemberDescription(null, null);
+
+            description.MemberType.Should().Be(MemberType.EnumMember);
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/Descriptions/EventDescriptionTests.cs b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/EventDescriptionTests.cs
new file mode 100644
index 0000000..6881164
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/EventDescriptionTests.cs
@@ -0,0 +1,51 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    [TestClass]
+    public class EventDescriptionTests
+    {
+        [TestMethod]
+        public void EventDescription_Constructor_Should_SetType()
+        {
+            var description = new EventDescription("System.String", null);
+
+            description.Type.Should().Be("System.String");
+        }
+
+        [TestMethod]
+        public void EventDescription_Constructor_Should_SetName()
+        {
+            var description = new EventDescription(null, "TestEvent");
+
+            description.Name.Should().Be("TestEvent");
+        }
+
+        [TestMethod]
+        public void EventDescription_MemberType_Should_BeProperty()
+        {
+            var description = new EventDescription(null, null);
+
+            description.MemberType.Should().Be(MemberType.Event);
+        }
+
+        [TestMethod]
+        public void EventDescription_HasInitializer_Should_BeDefaultFalse()
+        {
+            var description = new EventDescription(null, null);
+
+            description.HasInitializer.Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void EventDescription_HasInitializer_Should_BeTrueIfInitializerIsSet()
+        {
+            var description = new EventDescription(null, null);
+
+            description.Initializer = "1";
+
+            description.HasInitializer.Should().BeTrue();
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/Descriptions/FieldDescriptionTests.cs b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/FieldDescriptionTests.cs
new file mode 100644
index 0000000..2863fd6
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/FieldDescriptionTests.cs
@@ -0,0 +1,52 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    [TestClass]
+    public class FieldDescriptionTests
+    {
+        [TestMethod]
+        public void FieldDescription_Constructor_Should_SetType()
+        {
+            var description = new FieldDescription("System.String", null);
+
+            description.Type.Should().Be("System.String");
+        }
+
+        [TestMethod]
+        public void FieldDescription_Constructor_Should_SetName()
+        {
+            var description = new FieldDescription(null, "TestField");
+
+            description.Name.Should().Be("TestField");
+        }
+
+        [TestMethod]
+        public void FieldDescription_MemberType_Should_BeField()
+        {
+            var description = new FieldDescription(null, null);
+
+            description.MemberType.Should().Be(MemberType.Field);
+        }
+
+        [TestMethod]
+        public void FieldDescription_HasInitializer_Should_BeDefaultFalse()
+        {
+            var description = new FieldDescription(null, null);
+
+            description.HasInitializer.Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void FieldDescription_HasInitializer_Should_BeTrueIfInitializerIsSet()
+        {
+            var description = new FieldDescription(null, null);
+
+            description.Initializer = "1";
+
+            description.HasInitializer.Should().BeTrue();
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/Descriptions/InvocationDescriptionTests.cs b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/InvocationDescriptionTests.cs
new file mode 100644
index 0000000..79118c2
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/InvocationDescriptionTests.cs
@@ -0,0 +1,33 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    [TestClass]
+    public class InvocationDescriptionTests
+    {
+        [TestMethod]
+        public void InvocationDescription_Constructor_Should_SetName()
+        {
+            var description = new InvocationDescription(null, "TestInvocation");
+
+            description.Name.Should().Be("TestInvocation");
+        }
+
+        [TestMethod]
+        public void InvocationDescription_Constructor_Should_SetContainingType()
+        {
+            var description = new InvocationDescription("System.String", null);
+
+            description.ContainingType.Should().Be("System.String");
+        }
+
+        [TestMethod]
+        public void InvocationDescription_Arguments_Should_BeEmpty()
+        {
+            var description = new InvocationDescription(null, null);
+
+            description.Arguments.Should().BeEmpty();
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/Descriptions/MethodDescriptionTests.cs b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/MethodDescriptionTests.cs
new file mode 100644
index 0000000..cbdd544
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/MethodDescriptionTests.cs
@@ -0,0 +1,33 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    [TestClass]
+    public class MethodDescriptionTests
+    {
+        [TestMethod]
+        public void MethodDescription_Constructor_Should_SetType()
+        {
+            var description = new MethodDescription("System.String", null);
+
+            description.ReturnType.Should().Be("System.String");
+        }
+
+        [TestMethod]
+        public void MethodDescription_Constructor_Should_SetName()
+        {
+            var description = new MethodDescription(null, "TestMethod");
+
+            description.Name.Should().Be("TestMethod");
+        }
+
+        [TestMethod]
+        public void MethodDescription_MemberType_Should_BeMethod()
+        {
+            var description = new MethodDescription(null, null);
+
+            description.MemberType.Should().Be(MemberType.Method);
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/Descriptions/ParameterDescriptionTests.cs b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/ParameterDescriptionTests.cs
new file mode 100644
index 0000000..36c1f65
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/ParameterDescriptionTests.cs
@@ -0,0 +1,33 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    [TestClass]
+    public class ParameterDescriptionTests
+    {
+        [TestMethod]
+        public void ParameterDescription_Constructor_Should_SetType()
+        {
+            var description = new ParameterDescription("System.String", null);
+
+            description.Type.Should().Be("System.String");
+        }
+
+        [TestMethod]
+        public void ParameterDescription_Constructor_Should_SetName()
+        {
+            var description = new ParameterDescription(null, "TestParameter");
+
+            description.Name.Should().Be("TestParameter");
+        }
+
+        [TestMethod]
+        public void ParameterDescription_HasDefaultValue_Should_BeDefaultFalse()
+        {
+            var description = new ParameterDescription(null, null);
+
+            description.HasDefaultValue.Should().BeFalse();
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/Descriptions/PropertyDescriptionTests.cs b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/PropertyDescriptionTests.cs
new file mode 100644
index 0000000..02726ca
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/PropertyDescriptionTests.cs
@@ -0,0 +1,51 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    [TestClass]
+    public class PropertyDescriptionTests
+    {
+        [TestMethod]
+        public void PropertyDescription_Constructor_Should_SetType()
+        {
+            var description = new PropertyDescription("System.String", null);
+
+            description.Type.Should().Be("System.String");
+        }
+
+        [TestMethod]
+        public void PropertyDescription_Constructor_Should_SetName()
+        {
+            var description = new PropertyDescription(null, "TestProperty");
+
+            description.Name.Should().Be("TestProperty");
+        }
+
+        [TestMethod]
+        public void PropertyDescription_MemberType_Should_BeProperty()
+        {
+            var description = new PropertyDescription(null, null);
+
+            description.MemberType.Should().Be(MemberType.Property);
+        }
+
+        [TestMethod]
+        public void PropertyDescription_HasInitializer_Should_BeDefaultFalse()
+        {
+            var description = new PropertyDescription(null, null);
+
+            description.HasInitializer.Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void PropertyDescription_HasInitializer_Should_BeTrueIfInitializerIsSet()
+        {
+            var description = new PropertyDescription(null, null);
+
+            description.Initializer = "1";
+
+            description.HasInitializer.Should().BeTrue();
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/Descriptions/TypeDescriptionTests.cs b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/TypeDescriptionTests.cs
new file mode 100644
index 0000000..2f73294
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/Descriptions/TypeDescriptionTests.cs
@@ -0,0 +1,164 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    [TestClass]
+    public class TypeDescriptionTests
+    {
+        [TestMethod]
+        public void TypeDescription_GetHashCode_Should_BeTheSame()
+        {
+            var descriptionX = new TypeDescription(0, "TestNamespace.TestClass").GetHashCode();
+            var descriptionY = new TypeDescription(0, "TestNamespace.TestClass").GetHashCode();
+
+            descriptionX.Should().Be(descriptionY);
+        }
+
+        [TestMethod]
+        public void TypeDescription_GetHashCode_Should_ShouldBeTheSameForDifferentTypeTypes()
+        {
+            var descriptionX = new TypeDescription(TypeType.Class, "TestNamespace.TestClass").GetHashCode();
+            var descriptionY = new TypeDescription(TypeType.Interface, "TestNamespace.TestClass").GetHashCode();
+
+            descriptionX.Should().Be(descriptionY);
+        }
+
+        [TestMethod]
+        public void TypeDescription_GetHashCode_Should_DifferentNamesShouldDiffer()
+        {
+            var descriptionX = new TypeDescription(0, "TestNamespace.TestClass1").GetHashCode();
+            var descriptionY = new TypeDescription(0, "TestNamespace.TestClass2").GetHashCode();
+
+            descriptionX.Should().NotBe(descriptionY);
+        }
+
+        [TestMethod]
+        public void TypeDescription_Equals_Should_BeTrueForSameTypeDescriptions()
+        {
+            var descriptionX = new TypeDescription(0, "TestNamespace.TestClass");
+            var descriptionY = new TypeDescription(0, "TestNamespace.TestClass");
+
+            descriptionX.Equals(descriptionY).Should().BeTrue();
+        }
+
+        [TestMethod]
+        public void TypeDescription_Equals_Should_BeFalseForDifferentCasing()
+        {
+            var descriptionX = new TypeDescription(0, "TestNamespace.TestClass");
+            var descriptionY = new TypeDescription(0, "testnamespace.testclass");
+
+            descriptionX.Equals(descriptionY).Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void TypeDescription_Equals_Should_BeFalseForDifferentTypeDescriptions()
+        {
+            var descriptionX = new TypeDescription(0, "TestNamespace.TestClass1");
+            var descriptionY = new TypeDescription(0, "TestNamespace.TestClass2");
+
+            descriptionX.Equals(descriptionY).Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void TypeDescription_Equals_Should_BeFalseForDifferentObjects()
+        {
+            var descriptionX = new TypeDescription(0, "TestNamespace.TestClass");
+            var descriptionY = new object();
+
+            descriptionX.Equals(descriptionY).Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void TypeDescription_Name_Should_BeFullNameIfThereAreNoDots()
+        {
+            var description = new TypeDescription(0, "TestClass");
+
+            description.Name.Should().Be("TestClass");
+        }
+
+        [TestMethod]
+        public void TypeDescription_Name_Should_BeParsedFromFullName()
+        {
+            var description = new TypeDescription(0, "TestNamespace.TestClass");
+
+            description.Name.Should().Be("TestClass");
+        }
+
+        [TestMethod]
+        public void TypeDescription_Namespace_Should_BeEmptyIfThereAreNoDots()
+        {
+            var description = new TypeDescription(0, "TestClass");
+
+            description.Namespace.Should().BeEmpty();
+        }
+
+        [TestMethod]
+        public void TypeDescription_Namespace_Should_BeParsedFromFullName()
+        {
+            var description = new TypeDescription(0, "TestNamespace.TestClass");
+
+            description.Namespace.Should().Be("TestNamespace");
+        }
+
+        [TestMethod]
+        public void TypeDescription_Constructor_Should_SetFullName()
+        {
+            var description = new TypeDescription(0, "TestNamespace.TestClass");
+
+            description.FullName.Should().Be("TestNamespace.TestClass");
+        }
+
+        [TestMethod]
+        public void TypeDescription_Constructor_Should_SetFullNameEmptyIfNull()
+        {
+            var description = new TypeDescription(TypeType.Class, null);
+
+            description.FullName.Should().BeEmpty();
+        }
+
+        [TestMethod]
+        public void TypeDescription_Constructor_Should_SetType()
+        {
+            var description = new TypeDescription(TypeType.Struct, null);
+
+            description.Type.Should().Be(TypeType.Struct);
+        }
+
+        [TestMethod]
+        public void TypeDescription_AddMember_Should_ThrowEdescriptionception()
+        {
+            var description = new TypeDescription(0, null);
+
+            Action action = () => { description.AddMember(new UnsupportedMemberDescription(null)); };
+
+            action.Should().Throw<NotSupportedException>();
+        }
+
+        [TestMethod]
+        public void TypeDescription_BaseTypes_Should_BeEmpty()
+        {
+            var description = new TypeDescription(0, null);
+
+            description.BaseTypes.Should().BeEmpty();
+        }
+
+        [TestMethod]
+        public void TypeDescription_Attributes_Should_BeEmpty()
+        {
+            var description = new TypeDescription(0, null);
+
+            description.Attributes.Should().BeEmpty();
+        }
+
+        private class UnsupportedMemberDescription : MemberDescription
+        {
+            public UnsupportedMemberDescription(string name) : base(name)
+            {
+            }
+
+            public override MemberType MemberType => throw new NotImplementedException();
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/DocumentationCommentsDescriptionTests.cs b/tests/LivingDocumentation.Analyzer.Tests/DocumentationCommentsDescriptionTests.cs
new file mode 100644
index 0000000..3a92c69
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/DocumentationCommentsDescriptionTests.cs
@@ -0,0 +1,60 @@
+using FluentAssertions;
+using FluentAssertions.Execution;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    [TestClass]
+    public class DocumentationCommentsDescriptionTests
+    {
+        [TestMethod]
+        public void DefaultDocumentationSummary_Should_NotBeNull()
+        {
+            // Assign
+            var documentation = new DocumentationCommentsDescription();
+
+            // Assert
+            documentation.Summary.Should().NotBeNull();
+        }
+
+        [TestMethod]
+        public void DefaultDocumentationReturns_Should_NotBeNull()
+        {
+            // Assign
+            var documentation = new DocumentationCommentsDescription();
+
+            // Assert
+            documentation.Returns.Should().NotBeNull();
+        }
+
+        [TestMethod]
+        public void DefaultDocumentationRemarks_Should_NotBeNull()
+        {
+            // Assign
+            var documentation = new DocumentationCommentsDescription();
+
+            // Assert
+            documentation.Remarks.Should().NotBeNull();
+        }
+
+        [TestMethod]
+        public void DefaultDocumentationValue_Should_NotBeNull()
+        {
+            // Assign
+            var documentation = new DocumentationCommentsDescription();
+
+            // Assert
+            documentation.Value.Should().NotBeNull();
+        }
+
+        [TestMethod]
+        public void DefaultDocumentationExample_Should_NotBeNull()
+        {
+            // Assign
+            var documentation = new DocumentationCommentsDescription();
+
+            // Assert
+            documentation.Example.Should().NotBeNull();
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/DocumentationCommentsTests.cs b/tests/LivingDocumentation.Analyzer.Tests/DocumentationCommentsTests.cs
new file mode 100644
index 0000000..1d8c58f
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/DocumentationCommentsTests.cs
@@ -0,0 +1,400 @@
+using FluentAssertions;
+using FluentAssertions.Execution;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    [TestClass]
+    public class DocumentationCommentsTests
+    {
+        [TestMethod]
+        public void ClassWithComments_Should_HaveDocumentationParsed()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// This is a Test Class.
+            /// </summary>
+            /// <remarks>
+            /// This is a remark.
+            /// </remarks>
+            /// <example>
+            /// This is an example.
+            /// </example>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].DocumentationComments.Summary.Should().Be("This is a Test Class.");
+                types[0].DocumentationComments.Remarks.Should().Be("This is a remark.");
+                types[0].DocumentationComments.Example.Should().Be("This is an example.");
+            }
+        }
+
+        [TestMethod]
+        public void EventWithComments_Should_HaveDocumentationParsed()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <summary>
+                /// This is a Test Event.
+                /// </summary>
+                /// <remarks>
+                /// This is a remark.
+                /// </remarks>
+                /// <example>
+                /// This is an example.
+                /// </example>
+                /// <value>
+                /// This is the value.
+                /// </value>
+                event System.Action @event;
+
+                Test() { @event(); }
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Events[0].DocumentationComments.Summary.Should().Be("This is a Test Event.");
+                types[0].Events[0].DocumentationComments.Remarks.Should().Be("This is a remark.");
+                types[0].Events[0].DocumentationComments.Example.Should().Be("This is an example.");
+                types[0].Events[0].DocumentationComments.Value.Should().Be("This is the value.");
+            }
+        }
+
+        [TestMethod]
+        public void MultipleEventDeclarationsWithComments_Should_HaveDocumentationParsedForEveryEvent()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <summary>
+                /// These are Test Events.
+                /// </summary>
+                /// <remarks>
+                /// This is a remark.
+                /// </remarks>
+                /// <example>
+                /// This is an example.
+                /// </example>
+                /// <value>
+                /// This is the value.
+                /// </value>
+                event System.Action event1, event2;
+
+                Test() { event1(); event2(); }
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Events[0].DocumentationComments.Summary.Should().Be("These are Test Events.");
+                types[0].Events[0].DocumentationComments.Remarks.Should().Be("This is a remark.");
+                types[0].Events[0].DocumentationComments.Example.Should().Be("This is an example.");
+                types[0].Events[0].DocumentationComments.Value.Should().Be("This is the value.");
+
+                types[0].Events[1].DocumentationComments.Summary.Should().Be("These are Test Events.");
+                types[0].Events[1].DocumentationComments.Remarks.Should().Be("This is a remark.");
+                types[0].Events[1].DocumentationComments.Example.Should().Be("This is an example.");
+                types[0].Events[1].DocumentationComments.Value.Should().Be("This is the value.");
+            }
+        }
+
+        [TestMethod]
+        public void FieldWithComments_Should_HaveDocumentationParsed()
+        {
+            // Assign
+            var source = @"
+            public class Test
+            {
+                /// <summary>
+                /// This is a Test Field.
+                /// </summary>
+                /// <remarks>
+                /// This is a remark.
+                /// </remarks>
+                /// <example>
+                /// This is an example.
+                /// </example>
+                /// <value>
+                /// This is the value.
+                /// </value>
+                public string field;
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Fields[0].DocumentationComments.Summary.Should().Be("This is a Test Field.");
+                types[0].Fields[0].DocumentationComments.Remarks.Should().Be("This is a remark.");
+                types[0].Fields[0].DocumentationComments.Example.Should().Be("This is an example.");
+                types[0].Fields[0].DocumentationComments.Value.Should().Be("This is the value.");
+            }
+        }
+
+        [TestMethod]
+        public void MultipleFieldDeclarationsWithComments_Should_HaveDocumentationParsedForEveryField()
+        {
+            // Assign
+            var source = @"
+            public class Test
+            {
+                /// <summary>
+                /// These are Test Fields.
+                /// </summary>
+                /// <remarks>
+                /// This is a remark.
+                /// </remarks>
+                /// <example>
+                /// This is an example.
+                /// </example>
+                /// <value>
+                /// This is the value.
+                /// </value>
+                public string field1, field2;
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Fields[0].DocumentationComments.Summary.Should().Be("These are Test Fields.");
+                types[0].Fields[0].DocumentationComments.Remarks.Should().Be("This is a remark.");
+                types[0].Fields[0].DocumentationComments.Example.Should().Be("This is an example.");
+                types[0].Fields[0].DocumentationComments.Value.Should().Be("This is the value.");
+
+                types[0].Fields[1].DocumentationComments.Summary.Should().Be("These are Test Fields.");
+                types[0].Fields[1].DocumentationComments.Remarks.Should().Be("This is a remark.");
+                types[0].Fields[1].DocumentationComments.Example.Should().Be("This is an example.");
+                types[0].Fields[1].DocumentationComments.Value.Should().Be("This is the value.");
+            }
+        }
+
+        [TestMethod]
+        public void InterfaceWithComments_Should_HaveDocumentationParsed()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// This is a Test Interface.
+            /// </summary>
+            /// <remarks>
+            /// This is a remark.
+            /// </remarks>
+            /// <example>
+            /// This is an example.
+            /// </example>
+            interface Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].DocumentationComments.Summary.Should().Be("This is a Test Interface.");
+                types[0].DocumentationComments.Remarks.Should().Be("This is a remark.");
+                types[0].DocumentationComments.Example.Should().Be("This is an example.");
+            }
+        }
+
+        [TestMethod]
+        public void EnumWithComments_Should_HaveDocumentationParsed()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// This is a Test Enum.
+            /// </summary>
+            /// <remarks>
+            /// This is a remark.
+            /// </remarks>
+            /// <example>
+            /// This is an example.
+            /// </example>
+            enum Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].DocumentationComments.Summary.Should().Be("This is a Test Enum.");
+                types[0].DocumentationComments.Remarks.Should().Be("This is a remark.");
+                types[0].DocumentationComments.Example.Should().Be("This is an example.");
+            }
+        }
+
+        [TestMethod]
+        public void StructWithComments_Should_HaveDocumentationParsed()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// This is a Test Struct.
+            /// </summary>
+            /// <remarks>
+            /// This is a remark.
+            /// </remarks>
+            /// <example>
+            /// This is an example.
+            /// </example>
+            struct Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].DocumentationComments.Summary.Should().Be("This is a Test Struct.");
+                types[0].DocumentationComments.Remarks.Should().Be("This is a remark.");
+                types[0].DocumentationComments.Example.Should().Be("This is an example.");
+            }
+        }
+
+        [TestMethod]
+        public void MethodWithComments_Should_HaveDocumentationParsed()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <summary>
+                /// This is a Test Method.
+                /// </summary>
+                /// <remarks>
+                /// This is a remark.
+                /// </remarks>
+                /// <example>
+                /// This is an example.
+                /// </example>
+                /// <returns>
+                /// Returns a string.
+                /// </returns>
+                public string Method() { return null; }
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Methods[0].DocumentationComments.Summary.Should().Be("This is a Test Method.");
+                types[0].Methods[0].DocumentationComments.Remarks.Should().Be("This is a remark.");
+                types[0].Methods[0].DocumentationComments.Example.Should().Be("This is an example.");
+                types[0].Methods[0].DocumentationComments.Returns.Should().Be("Returns a string.");
+            }
+        }
+
+        [TestMethod]
+        public void ConstructorWithComments_Should_HaveDocumentationParsed()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <summary>
+                /// This is a Test Constructor.
+                /// </summary>
+                /// <remarks>
+                /// This is a remark.
+                /// </remarks>
+                /// <example>
+                /// This is an example.
+                /// </example>
+                /// <returns>
+                /// Returns a string.
+                /// </returns>
+                Test() {}
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Constructors[0].DocumentationComments.Summary.Should().Be("This is a Test Constructor.");
+                types[0].Constructors[0].DocumentationComments.Remarks.Should().Be("This is a remark.");
+                types[0].Constructors[0].DocumentationComments.Example.Should().Be("This is an example.");
+                types[0].Constructors[0].DocumentationComments.Returns.Should().Be("Returns a string.");
+            }
+        }
+
+        [TestMethod]
+        public void PropertyWithComments_Should_HaveDocumentationParsed()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <summary>
+                /// This is a Test Property.
+                /// </summary>
+                /// <remarks>
+                /// This is a remark.
+                /// </remarks>
+                /// <example>
+                /// This is an example.
+                /// </example>
+                /// <value>
+                /// This is the value.
+                /// </value>
+                public string Property { get; set; }
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Properties[0].DocumentationComments.Summary.Should().Be("This is a Test Property.");
+                types[0].Properties[0].DocumentationComments.Remarks.Should().Be("This is a remark.");
+                types[0].Properties[0].DocumentationComments.Example.Should().Be("This is an example.");
+                types[0].Properties[0].DocumentationComments.Value.Should().Be("This is the value.");
+            }
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/DocumentationTagContentParsingTests.cs b/tests/LivingDocumentation.Analyzer.Tests/DocumentationTagContentParsingTests.cs
new file mode 100644
index 0000000..4e95b1c
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/DocumentationTagContentParsingTests.cs
@@ -0,0 +1,841 @@
+using FluentAssertions;
+using FluentAssertions.Execution;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    [TestClass]
+    public class DocumentationTagContentParsingTests
+    {
+        [TestMethod]
+        public void Summary_Should_BeRead()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// A summary.
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("A summary.");
+        }
+
+        [TestMethod]
+        public void Remarks_Should_BeRead()
+        {
+            // Assign
+            var source = @"
+            /// <remarks>
+            /// A remark.
+            /// </remarks>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Remarks.Should().Be("A remark.");
+        }
+
+        [TestMethod]
+        public void Example_Should_BeRead()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <example>
+                /// The following example demonstrates the use of this method.
+                /// 
+                /// <code>
+                /// // Get a new random number
+                /// SampleClass sc = new SampleClass(10);
+                /// 
+                /// int random = sc.GetRandomNumber();
+                ///
+                /// Console.WriteLine(""Random value: {0}"", random);
+                /// </code>
+                /// </example>
+                void Method() {}
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].Methods[0].DocumentationComments.Example.Should().Be("The following example demonstrates the use of this method.\n\n// Get a new random number\nSampleClass sc = new SampleClass(10);\n\nint random = sc.GetRandomNumber();\n\nConsole.WriteLine(\"Random value: {0}\", random);");
+        }
+
+
+        [TestMethod]
+        public void Exception_Should_BeRead()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <exception cref=""System.Exception"">An exception.</exception>
+                void Method() {}
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Methods[0].DocumentationComments.Exceptions.Should().HaveCount(1);
+                types[0].Methods[0].DocumentationComments.Exceptions.Should().Contain("System.Exception", "An exception."); 
+            }
+        }
+
+        [TestMethod]
+        public void Exceptions_Should_BeRead()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <exception cref=""System.Exception"">An exception.</exception>
+                /// <exception cref=""System.StackOverflowException"">Another exception.</exception>
+                void Method() {}
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Methods[0].DocumentationComments.Exceptions.Should().HaveCount(2);
+                types[0].Methods[0].DocumentationComments.Exceptions.Should().Contain("System.Exception", "An exception.");
+                types[0].Methods[0].DocumentationComments.Exceptions.Should().Contain("System.StackOverflowException", "Another exception.");
+            }
+        }
+
+        [TestMethod]
+        public void Param_Should_BeRead()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <param name=""param"">This is a param.</param>
+                void Method(string param) {}
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Methods[0].DocumentationComments.Params.Should().HaveCount(1);
+                types[0].Methods[0].DocumentationComments.Params.Should().Contain("param", "This is a param.");
+            }
+        }
+
+        [TestMethod]
+        public void Params_Should_BeRead()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <param name=""param1"">This is the first parameter.</param>
+                /// <param name=""param2"">This is the second parameter.</param>
+                void Method(string param1, string param2) {}
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Methods[0].DocumentationComments.Params.Should().HaveCount(2);
+                types[0].Methods[0].DocumentationComments.Params.Should().Contain("param1", "This is the first parameter.");
+                types[0].Methods[0].DocumentationComments.Params.Should().Contain("param2", "This is the second parameter.");
+            }
+        }
+
+        [TestMethod]
+        public void Permission_Should_BeRead()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <permission cref=""System.Security.PermissionSet"">A permission.</permission>
+                void Method() {}
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Methods[0].DocumentationComments.Permissions.Should().HaveCount(1);
+                types[0].Methods[0].DocumentationComments.Permissions.Should().Contain("System.Security.PermissionSet", "A permission.");
+            }
+        }
+
+        [TestMethod]
+        public void Permissions_Should_BeRead()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <permission cref=""System.Security.Permissions.EnvironmentPermission"">A permission.</permission>
+                /// <permission cref=""System.Security.Permissions.FileIOPermission"">Another permission.</permission>
+                void Method() {}
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Methods[0].DocumentationComments.Permissions.Should().HaveCount(2);
+                types[0].Methods[0].DocumentationComments.Permissions.Should().Contain("System.Security.Permissions.EnvironmentPermission", "A permission.");
+                types[0].Methods[0].DocumentationComments.Permissions.Should().Contain("System.Security.Permissions.FileIOPermission", "Another permission.");
+            }
+        }
+
+        [TestMethod]
+        public void SeeAlso_Should_BeRead()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <seealso cref=""System.String"" />
+                void Method() {}
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Methods[0].DocumentationComments.SeeAlsos.Should().HaveCount(1);
+                types[0].Methods[0].DocumentationComments.SeeAlsos.Should().Contain("System.String", "System.String");
+            }
+        }
+
+        [TestMethod]
+        public void SeeAlsos_Should_BeRead()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <seealso cref=""System.String"" />
+                /// <seealso cref=""System.Object"">See also.</seealso>
+                void Method() {}
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Methods[0].DocumentationComments.SeeAlsos.Should().HaveCount(2);
+                types[0].Methods[0].DocumentationComments.SeeAlsos.Should().Contain("System.String", "System.String");
+                types[0].Methods[0].DocumentationComments.SeeAlsos.Should().Contain("System.Object", "See also.");
+            }
+        }
+
+        [TestMethod]
+        public void TypeParam_Should_BeRead()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <typeparam name=""T"">This is a type param.</typeparam>
+                void Method<T>() {}
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Methods[0].DocumentationComments.TypeParams.Should().HaveCount(1);
+                types[0].Methods[0].DocumentationComments.TypeParams.Should().Contain("T", "This is a type param.");
+            }
+        }
+
+        [TestMethod]
+        public void TypeParams_Should_BeRead()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <typeparam name=""T1"">This is the first type parameter.</typeparam>
+                /// <typeparam name=""T2"">This is the second type parameter.</typeparam>
+                void Method<T1, T2>() {}
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Methods[0].DocumentationComments.TypeParams.Should().HaveCount(2);
+                types[0].Methods[0].DocumentationComments.TypeParams.Should().Contain("T1", "This is the first type parameter.");
+                types[0].Methods[0].DocumentationComments.TypeParams.Should().Contain("T2", "This is the second type parameter.");
+            }
+        }
+
+        [TestMethod]
+        public void SummaryWithWhitespace_Should_BeTrimmed()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// 
+            ///   A  
+            ///   
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("A");
+        }
+
+        [TestMethod]
+        public void NonSummaryWithWhitespace_Should_OnlyNonNewLinesBeTrimmed()
+        {
+            // Assign
+            var source = @"
+            /// <remarks>
+            ///   A  
+            ///   B
+            /// </remarks>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Remarks.Should().Be("A\nB");
+        }
+
+        [TestMethod]
+        public void TagWithSeeAlso_Should_IgnoreSeeAlso()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <summary>
+                /// <seealso cref=""System.Object"">See also.</seealso>
+                /// </summary>
+                public void Method() {}
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].Methods[0].DocumentationComments.Summary.Should().BeEmpty();
+        }
+
+        [TestMethod]
+        public void TagWithSeeAlso_Should_AddToSeeAlsos()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <summary>
+                /// <seealso cref=""System.Object"">See also.</seealso>
+                /// </summary>
+                public void Method() {}
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            using (new AssertionScope())
+            {
+                types[0].Methods[0].DocumentationComments.SeeAlsos.Should().HaveCount(1);
+                types[0].Methods[0].DocumentationComments.SeeAlsos.Should().Contain("System.Object", "See also.");
+            }
+        }
+
+        [TestMethod]
+        public void TagWithParamRefName_Should_HaveNameAsComment()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <summary>
+                /// A <paramref name=""b"" /> c
+                /// </summary>
+                public void Method(string b) {}
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].Methods[0].DocumentationComments.Summary.Should().Be("A b c");
+        }
+
+        [TestMethod]
+        public void TagWithTypeParamRefName_Should_HaveNameAsComment()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                /// <summary>
+                /// A <typeparamref name=""b""/> c
+                /// </summary>
+                public void Method<b>() {}
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].Methods[0].DocumentationComments.Summary.Should().Be("A b c");
+        }
+
+        [TestMethod]
+        public void SummaryWithLineBreaksBetweenText_Should_HaveOnlySingleSpaceBetweenText()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// a
+            /// 
+            /// b
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("a b");
+        }
+
+        [TestMethod]
+        public void SummaryWithMixOfTextAndPara_Should_HaveALineBreakBetweenText()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// a
+            /// <para>b</para>
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("a\nb");
+        }
+
+        [TestMethod]
+        public void SummaryWithMultipleParas_Should_HaveLinebreakBetweenText()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// <para>a</para>
+            /// <para>b</para>
+            /// <para>c</para>
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("a\nb\nc");
+        }
+
+        [TestMethod]
+        public void TagWithSeeWithInnertext_Should_HaveInnerTextAsComment()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// A <see cref=""Test"">b</see> c
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("A b c");
+        }
+
+        [TestMethod]
+        public void TagWithSee_Should_HaveCrefAsComment()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// A <see cref=""b"" /> c
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("A b c");
+        }
+
+        [TestMethod]
+        public void TagWithCode_Should_HaveInnerTextAsComment()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// A <c>b</c> c
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("A b c");
+        }
+
+        [TestMethod]
+        public void TagWithInvalidList_Should_HaveListItemsAsInlineTextInComment()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// <list>
+            /// <item>First item</item>
+            /// <item>Second item</item>
+            /// </list>
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("First item Second item");
+        }
+
+        [TestMethod]
+        public void TagWithBulletList_Should_HaveListItemsAsLinesInComment()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// <list type=""bullet"">
+            /// <item>First item</item>
+            /// <item>Second item</item>
+            /// </list>
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("* First item\n* Second item");
+        }
+
+        [TestMethod]
+        public void TagWithBulletListWithDescriptions_Should_HaveListItemsAsLinesInComment()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// <list type=""bullet"">
+            /// <item><description>First item</description></item>
+            /// <item><description>Second item</description></item>
+            /// </list>
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("* First item\n* Second item");
+        }
+
+        [TestMethod]
+        public void TagWithBulletListWithTermsAndDescriptions_Should_HaveListItemsAsLinesInComment()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// <list type=""bullet"">
+            /// <item>
+            /// <term>Term 1</term>
+            /// <description>First item</description>
+            /// </item>
+            /// <item>
+            /// <term>Term 2</term>
+            /// <description>Second item</description>
+            /// </item>
+            /// </list>
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("* Term 1 - First item\n* Term 2 - Second item");
+        }
+
+
+
+        [TestMethod]
+        public void TagWithNumberedList_Should_HaveNumberedListItemsAsLinesInComment()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// <list type=""number"">
+            /// <item>First item</item>
+            /// <item>Second item</item>
+            /// </list>
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("1. First item\n2. Second item");
+        }
+
+        [TestMethod]
+        public void TagWithNumberedListWithStart_Should_HaveCorrectNumberedListItemsAsLinesInComment()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// <list type=""number"" start=""3"">
+            /// <item>First item</item>
+            /// <item>Second item</item>
+            /// </list>
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("3. First item\n4. Second item");
+        }
+
+        [TestMethod]
+        public void TagWithNumberedListWithDescriptions_Should_HaveNumberedListItemsAsLinesInComment()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// <list type=""number"">
+            /// <item><description>First item</description></item>
+            /// <item><description>Second item</description></item>
+            /// </list>
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("1. First item\n2. Second item");
+        }
+
+        [TestMethod]
+        public void TagWithNumberedListWithTermsAndDescriptions_Should_HaveNumberedListItemsAsLinesInComment()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// <list type=""number"">
+            /// <item>
+            /// <term>Term 1</term>
+            /// <description>First item</description>
+            /// </item>
+            /// <item>
+            /// <term>Term 2</term>
+            /// <description>Second item</description>
+            /// </item>
+            /// </list>
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("1. Term 1 - First item\n2. Term 2 - Second item");
+        }
+
+        [TestMethod]
+        public void TagWithDefinitionListWithTermsAndDescriptions_Should_HaveSeperateLinesWithTermAndDescriptionIndented()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// <list type=""definition"">
+            /// <item>
+            /// <term>Term 1</term>
+            /// <description>First item</description>
+            /// </item>
+            /// <item>
+            /// <term>Term 2</term>
+            /// <description>Second item</description>
+            /// </item>
+            /// </list>
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("Term 1\n    First item\nTerm 2\n    Second item");
+        }
+
+        [TestMethod]
+        public void TagWithNestedContent_Should_RenderCorrectly()
+        {
+            // Assign
+            var source = @"
+            /// <summary>
+            /// This is a summary with mixed content.
+            /// <para>A <see cref=""System.Object"">paragraph</see></para>
+            /// <para>Another <paramref name=""paragraph""/></para>
+            /// <list type=""definition"">
+            /// <item>
+            /// <term>Term 1</term>
+            /// <description>First <typeparamref name=""item""/></description>
+            /// </item>
+            /// <item>
+            /// <term>Term <c>2</c></term>
+            /// <description><para>Second item</para></description>
+            /// </item>
+            /// </list>
+            /// <code>
+            /// class ACodeSample { }
+            /// </code>
+            /// More text <c>null</c> and more text
+            /// <seealso cref=""System.Object""/>
+            /// </summary>
+            class Test
+            {
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].DocumentationComments.Summary.Should().Be("This is a summary with mixed content.\nA paragraph\nAnother paragraph\nTerm 1\n    First item\nTerm 2\n    Second item\nclass ACodeSample { }\nMore text null and more text");
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/EnumModifierTests.cs b/tests/LivingDocumentation.Analyzer.Tests/EnumModifierTests.cs
index 1e0baae..4190851 100644
--- a/tests/LivingDocumentation.Analyzer.Tests/EnumModifierTests.cs
+++ b/tests/LivingDocumentation.Analyzer.Tests/EnumModifierTests.cs
@@ -1,9 +1,5 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.Collections.Generic;
-using System.Linq;
 using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace LivingDocumentation.Analyzer.Tests
 {
@@ -21,7 +17,7 @@ enum Test
             ";
 
             // Act
-            var types = VisitSyntaxTree(source);
+            var types = TestHelper.VisitSyntaxTree(source);
 
             // Assert
             types[0].Modifiers.Should().Be(Modifier.Internal);
@@ -38,7 +34,7 @@ public enum Test
             ";
 
             // Act
-            var types = VisitSyntaxTree(source);
+            var types = TestHelper.VisitSyntaxTree(source);
 
             // Assert
             types[0].Modifiers.Should().Be(Modifier.Public);
@@ -56,33 +52,10 @@ public enum Test
             ";
 
             // Act
-            var types = VisitSyntaxTree(source);
+            var types = TestHelper.VisitSyntaxTree(source);
 
             // Assert
             types[0].EnumMembers[0].Modifiers.Should().Be(Modifier.Public);
         }
-
-        private static IReadOnlyList<TypeDescription> VisitSyntaxTree(string source)
-        {
-            source.Should().NotBeNullOrWhiteSpace("without source code there is nothing to test");
-
-            var syntaxTree = CSharpSyntaxTree.ParseText(source.Trim());
-            var compilation = CSharpCompilation.Create("Test")
-                                               .WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
-                                               .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
-                                               .AddSyntaxTrees(syntaxTree);
-
-            var diagnostics = compilation.GetDiagnostics();
-            diagnostics.Should().HaveCount(0, "there shoudn't be any compile errors");
-
-            var semanticModel = compilation.GetSemanticModel(syntaxTree, true);
-
-            var types = new List<TypeDescription>();
-
-            var visitor = new SourceAnalyzer(semanticModel, types, Enumerable.Empty<AssemblyIdentity>().ToList());
-            visitor.Visit(syntaxTree.GetRoot());
-
-            return types;
-        }
     }
 }
diff --git a/tests/LivingDocumentation.Analyzer.Tests/EventDeclarationTests.cs b/tests/LivingDocumentation.Analyzer.Tests/EventDeclarationTests.cs
new file mode 100644
index 0000000..d923c23
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/EventDeclarationTests.cs
@@ -0,0 +1,69 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    [TestClass]
+    public class EventDeclarationTests
+    {
+        [TestMethod]
+        public void EventDeclaration_Should_CreateEventDescription()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                event System.Action @event;
+
+                Test() { @event(); }
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].Events.Should().HaveCount(1);
+        }
+
+        [TestMethod]
+        public void EventDeclaration_Should_CreateEventDescriptionTests2()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                event System.Action @event;
+
+                Test() { @event(); }
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].Events.Should().HaveCount(1);
+        }
+
+        [TestMethod]
+        public void MultipleEventDeclaration_Should_CreateEventDescriptionPerEvent()
+        {
+            // Assign
+            var source = @"
+            class Test
+            {
+                event System.Action event1, event2;
+
+                Test() { event1(); event2(); }
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].Events.Should().HaveCount(2);
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/FieldDeclarationTests.cs b/tests/LivingDocumentation.Analyzer.Tests/FieldDeclarationTests.cs
new file mode 100644
index 0000000..223bf43
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/FieldDeclarationTests.cs
@@ -0,0 +1,45 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    [TestClass]
+    public class FieldDeclarationTests
+    {
+        [TestMethod]
+        public void FieldDeclaration_Should_CreateFieldDescription()
+        {
+            // Assign
+            var source = @"
+            public class Test
+            {
+                public string field;
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].Fields.Should().HaveCount(1);
+        }
+
+        [TestMethod]
+        public void MultipleFieldDeclaration_Should_CreateFieldDescriptionPerField()
+        {
+            // Assign
+            var source = @"
+            public class Test
+            {
+                public string field1, field2;
+            }
+            ";
+
+            // Act
+            var types = TestHelper.VisitSyntaxTree(source);
+
+            // Assert
+            types[0].Fields.Should().HaveCount(2);
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.Analyzer.Tests/ForEachTests.cs b/tests/LivingDocumentation.Analyzer.Tests/ForEachTests.cs
index be9b3be..36e1d38 100644
--- a/tests/LivingDocumentation.Analyzer.Tests/ForEachTests.cs
+++ b/tests/LivingDocumentation.Analyzer.Tests/ForEachTests.cs
@@ -1,9 +1,5 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.Collections.Generic;
-using System.Linq;
 using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace LivingDocumentation.Analyzer.Tests
 {
@@ -28,7 +24,7 @@ void Method()
             ";
 
             // Act
-            var types = VisitSyntaxTree(source);
+            var types = TestHelper.VisitSyntaxTree(source);
 
             // Assert
             types[0].Methods[0].Statements[0].Should().BeOfType<ForEach>();
@@ -53,34 +49,11 @@ void Method()
             ";
 
             // Act
-            var types = VisitSyntaxTree(source);
+            var types = TestHelper.VisitSyntaxTree(source);
 
             // Assert
             var forEach = types[0].Methods[0].Statements[0];
             forEach.Statements.Should().HaveCount(1);
         }
-
-        private static IReadOnlyList<TypeDescription> VisitSyntaxTree(string source)
-        {
-            source.Should().NotBeNullOrWhiteSpace("without source code there is nothing to test");
-
-            var syntaxTree = CSharpSyntaxTree.ParseText(source.Trim());
-            var compilation = CSharpCompilation.Create("Test")
-                                               .WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
-                                               .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
-                                               .AddSyntaxTrees(syntaxTree);
-
-            var diagnostics = compilation.GetDiagnostics();
-            diagnostics.Should().HaveCount(0, "there shoudn't be any compile errors");
-
-            var semanticModel = compilation.GetSemanticModel(syntaxTree, true);
-
-            var types = new List<TypeDescription>();
-
-            var visitor = new SourceAnalyzer(semanticModel, types, Enumerable.Empty<AssemblyIdentity>().ToList());
-            visitor.Visit(syntaxTree.GetRoot());
-
-            return types;
-        }
     }
 }
diff --git a/tests/LivingDocumentation.Analyzer.Tests/LivingDocumentation.Analyzer.Tests.csproj b/tests/LivingDocumentation.Analyzer.Tests/LivingDocumentation.Analyzer.Tests.csproj
index 3f66998..25e0b95 100644
--- a/tests/LivingDocumentation.Analyzer.Tests/LivingDocumentation.Analyzer.Tests.csproj
+++ b/tests/LivingDocumentation.Analyzer.Tests/LivingDocumentation.Analyzer.Tests.csproj
@@ -7,11 +7,11 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentAssertions" Version="5.7.0" />
+    <PackageReference Include="FluentAssertions" Version="5.10.0" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="2.9.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.1.1" />
-    <PackageReference Include="MSTest.TestAdapter" Version="1.4.0" />
-    <PackageReference Include="MSTest.TestFramework" Version="1.4.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="2.0.0" />
+    <PackageReference Include="MSTest.TestFramework" Version="2.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/LivingDocumentation.Analyzer.Tests/StructModifierTests.cs b/tests/LivingDocumentation.Analyzer.Tests/StructModifierTests.cs
index 9eae806..b1e3b27 100644
--- a/tests/LivingDocumentation.Analyzer.Tests/StructModifierTests.cs
+++ b/tests/LivingDocumentation.Analyzer.Tests/StructModifierTests.cs
@@ -1,9 +1,5 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.Collections.Generic;
-using System.Linq;
 using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 namespace LivingDocumentation.Analyzer.Tests
 {
@@ -21,7 +17,7 @@ struct Test
             ";
 
             // Act
-            var types = VisitSyntaxTree(source);
+            var types = TestHelper.VisitSyntaxTree(source);
 
             // Assert
             types[0].Modifiers.Should().Be(Modifier.Internal);
@@ -38,7 +34,7 @@ public struct Test
             ";
 
             // Act
-            var types = VisitSyntaxTree(source);
+            var types = TestHelper.VisitSyntaxTree(source);
 
             // Assert
             types[0].Modifiers.Should().Be(Modifier.Public);
@@ -58,7 +54,7 @@ struct NestedTest
             ";
 
             // Act
-            var types = VisitSyntaxTree(source);
+            var types = TestHelper.VisitSyntaxTree(source);
 
             // Assert
             types[1].Modifiers.Should().Be(Modifier.Private);
@@ -78,33 +74,10 @@ public struct NestedTest
             ";
 
             // Act
-            var types = VisitSyntaxTree(source);
+            var types = TestHelper.VisitSyntaxTree(source);
 
             // Assert
             types[1].Modifiers.Should().Be(Modifier.Public);
         }
-
-        private static IReadOnlyList<TypeDescription> VisitSyntaxTree(string source)
-        {
-            source.Should().NotBeNullOrWhiteSpace("without source code there is nothing to test");
-
-            var syntaxTree = CSharpSyntaxTree.ParseText(source.Trim());
-            var compilation = CSharpCompilation.Create("Test")
-                                               .WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
-                                               .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
-                                               .AddSyntaxTrees(syntaxTree);
-
-            var diagnostics = compilation.GetDiagnostics();
-            diagnostics.Should().HaveCount(0, "there shoudn't be any compile errors");
-
-            var semanticModel = compilation.GetSemanticModel(syntaxTree, true);
-
-            var types = new List<TypeDescription>();
-
-            var visitor = new SourceAnalyzer(semanticModel, types, Enumerable.Empty<AssemblyIdentity>().ToList());
-            visitor.Visit(syntaxTree.GetRoot());
-
-            return types;
-        }
     }
 }
diff --git a/tests/LivingDocumentation.Analyzer.Tests/TestHelper.cs b/tests/LivingDocumentation.Analyzer.Tests/TestHelper.cs
new file mode 100644
index 0000000..41f5a2b
--- /dev/null
+++ b/tests/LivingDocumentation.Analyzer.Tests/TestHelper.cs
@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using FluentAssertions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace LivingDocumentation.Analyzer.Tests
+{
+    internal class TestHelper
+    {
+        public static IReadOnlyList<TypeDescription> VisitSyntaxTree(string source)
+        {
+            source.Should().NotBeNullOrWhiteSpace("without source code there is nothing to test");
+
+            var syntaxTree = CSharpSyntaxTree.ParseText(source.Trim());
+            var compilation = CSharpCompilation.Create("Test")
+                                               .WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
+                                               .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
+                                               .AddSyntaxTrees(syntaxTree);
+
+            var diagnostics = compilation.GetDiagnostics();
+            diagnostics.Should().HaveCount(0, "there shoudn't be any compile errors");
+
+            var semanticModel = compilation.GetSemanticModel(syntaxTree, true);
+
+            var types = new List<TypeDescription>();
+
+            var visitor = new SourceAnalyzer(semanticModel, types);
+            visitor.Visit(syntaxTree.GetRoot());
+
+            return types;
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.RenderExtensions.Tests/LivingDocumentation.RenderExtensions.Tests.csproj b/tests/LivingDocumentation.RenderExtensions.Tests/LivingDocumentation.RenderExtensions.Tests.csproj
new file mode 100644
index 0000000..9317872
--- /dev/null
+++ b/tests/LivingDocumentation.RenderExtensions.Tests/LivingDocumentation.RenderExtensions.Tests.csproj
@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.2</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="FluentAssertions" Version="5.10.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="2.0.0" />
+    <PackageReference Include="MSTest.TestFramework" Version="2.0.0" />
+    <PackageReference Include="coverlet.collector" Version="1.0.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\LivingDocumentation.Render\LivingDocumentation.RenderExtensions.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/LivingDocumentation.RenderExtensions.Tests/StringExtensionsTests.GenericTypes.cs b/tests/LivingDocumentation.RenderExtensions.Tests/StringExtensionsTests.GenericTypes.cs
new file mode 100644
index 0000000..7042857
--- /dev/null
+++ b/tests/LivingDocumentation.RenderExtensions.Tests/StringExtensionsTests.GenericTypes.cs
@@ -0,0 +1,119 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.RenderExtensions.Tests
+{
+    public partial class StringExtensionsTests
+    {
+        [TestMethod]
+        public void GenericTypes_NonGenericType_Should_ReturnEmptyList()
+        {
+            // Assign
+            var type = "System.Object";
+
+            // Act
+            var result = type.GenericTypes();
+
+            // Assert
+            result.Should().BeEmpty();
+        }
+
+        [TestMethod]
+        public void GenericTypes_GenericList_Should_ReturnGenericType()
+        {
+            // Assign
+            var type = "System.Collections.Generic.List<System.String>";
+
+            // Act
+            var result = type.GenericTypes();
+
+            // Assert
+            var expectedTypes = new[] { "System.String" };
+            result.Should().Equal(expectedTypes);
+        }
+
+        [TestMethod]
+        public void GenericTypes_GenericListWithWhitespace_Should_ReturnGenericType()
+        {
+            // Assign
+            var type = "System.Collections.Generic.List< System.String >";
+
+            // Act
+            var result = type.GenericTypes();
+
+            // Assert
+            var expectedTypes = new[] { "System.String" };
+            result.Should().Equal(expectedTypes);
+        }
+
+        [TestMethod]
+        public void GenericTypes_GenericDictionary_Should_ReturnKeyAndValueType()
+        {
+            // Assign
+            var type = "System.Collections.Generic.Dictionary<System.String,System.String>";
+
+            // Act
+            var result = type.GenericTypes();
+
+            // Assert
+            var expectedTypes = new[] { "System.String", "System.String" };
+            result.Should().Equal(expectedTypes);
+        }
+
+        [TestMethod]
+        public void GenericTypes_GenericDictionaryWithWhitespace_Should_ReturnKeyAndValueType()
+        {
+            // Assign
+            var type = "System.Collections.Generic.Dictionary< System.String , System.String >";
+
+            // Act
+            var result = type.GenericTypes();
+
+            // Assert
+            var expectedTypes = new[] { "System.String", "System.String" };
+            result.Should().Equal(expectedTypes);
+        }
+
+        [TestMethod]
+        public void GenericTypes_GenericInGeneric_Should_ReturnCorrectGeneric()
+        {
+            // Assign
+            var type = "System.Collections.Generic.List<System.Nullable<System.Int32>>";
+
+            // Act
+            var result = type.GenericTypes();
+
+            // Assert
+            var expectedTypes = new[] { "System.Nullable<System.Int32>" };
+            result.Should().Equal(expectedTypes);
+        }
+
+        [TestMethod]
+        public void GenericTypes_GenericInGenericWithWhitespace_Should_ReturnCorrectGeneric()
+        {
+            // Assign
+            var type = "System.Collections.Generic.List< System.Nullable< System.Int32 > >";
+
+            // Act
+            var result = type.GenericTypes();
+
+            // Assert
+            var expectedTypes = new[] { "System.Nullable< System.Int32 >" };
+            result.Should().Equal(expectedTypes);
+        }
+
+        [TestMethod]
+        public void GenericTypes_GenericWithDictionaryInGeneric_Should_ReturnGenericDictionary()
+        {
+            // Assign
+            var type = "System.Nullable<System.Collections.Generic.Dictionary<System.Int32,System.Object>>";
+
+            // Act
+            var result = type.GenericTypes();
+
+            // Assert
+            var expectedTypes = new[] { "System.Collections.Generic.Dictionary<System.Int32,System.Object>" };
+            result.Should().Equal(expectedTypes);
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.RenderExtensions.Tests/StringExtensionsTests.IsEnumerable.cs b/tests/LivingDocumentation.RenderExtensions.Tests/StringExtensionsTests.IsEnumerable.cs
new file mode 100644
index 0000000..3441c0e
--- /dev/null
+++ b/tests/LivingDocumentation.RenderExtensions.Tests/StringExtensionsTests.IsEnumerable.cs
@@ -0,0 +1,191 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.RenderExtensions.Tests
+{
+    [TestClass]
+    public partial class StringExtensionsTests
+    {
+        [TestMethod]
+        public void IsEnumerable_GenericLinkedList_Should_ReturnTrue()
+        {
+            // Assign
+            var type = "System.Collections.Generic.LinkedList<System.String>";
+
+            // Act
+            var result = type.IsEnumerable();
+
+            // Assert
+            result.Should().BeTrue();
+        }
+
+        [TestMethod]
+        public void IsEnumerable_GenericIList_Should_ReturnTrue()
+        {
+            // Assign
+            var type = "System.Collections.Generic.IList<System.String>";
+
+            // Act
+            var result = type.IsEnumerable();
+
+            // Assert
+            result.Should().BeTrue();
+        }
+
+        [TestMethod]
+        public void IsEnumerable_GenericDictionaryEnumerator_Should_ReturnFalse()
+        {
+            // Assign
+            var type = "System.Collections.Generic.Dictionary<System.String,System.String>.Enumerator";
+
+            // Act
+            var result = type.IsEnumerable();
+
+            // Assert
+            result.Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void IsEnumerable_GenericComparer_Should_ReturnFalse()
+        {
+            // Assign
+            var type = "System.Collections.Generic.Comparer<System.String,System.String>";
+
+            // Act
+            var result = type.IsEnumerable();
+
+            // Assert
+            result.Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void IsEnumerable_GenericKeyNotFoundException_Should_ReturnFalse()
+        {
+            // Assign
+            var type = "System.Collections.Generic.KeyNotFoundException";
+
+            // Act
+            var result = type.IsEnumerable();
+
+            // Assert
+            result.Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void IsEnumerable_ConcurrentConcurrentStack_Should_ReturnTrue()
+        {
+            // Assign
+            var type = "System.Collections.Concurrent.ConcurrentStack<System.String>";
+
+            // Act
+            var result = type.IsEnumerable();
+
+            // Assert
+            result.Should().BeTrue();
+        }
+
+        [TestMethod]
+        public void IsEnumerable_ConcurrentPartitioner_Should_ReturnFalse()
+        {
+            // Assign
+            var type = "System.Collections.Concurrent.Partitioner";
+
+            // Act
+            var result = type.IsEnumerable();
+
+            // Assert
+            result.Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void IsEnumerable_ConcurrentOrderablePartitioner_Should_ReturnFalse()
+        {
+            // Assign
+            var type = "System.Collections.Concurrent.OrderablePartitioner<System.String>";
+
+            // Act
+            var result = type.IsEnumerable();
+
+            // Assert
+            result.Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void IsEnumerable_ArrayList_Should_ReturnTrue()
+        {
+            // Assign
+            var type = "System.Collections.ArrayList";
+
+            // Act
+            var result = type.IsEnumerable();
+
+            // Assert
+            result.Should().BeTrue();
+        }
+
+        [TestMethod]
+        public void IsEnumerable_CaseInsensitiveComparer_Should_ReturnFalse()
+        {
+            // Assign
+            var type = "System.Collections.CaseInsensitiveComparer";
+
+            // Act
+            var result = type.IsEnumerable();
+
+            // Assert
+            result.Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void IsEnumerable_CaseInsensitiveHashCodeProvider_Should_ReturnFalse()
+        {
+            // Assign
+            var type = "System.Collections.CaseInsensitiveHashCodeProvider";
+
+            // Act
+            var result = type.IsEnumerable();
+
+            // Assert
+            result.Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void IsEnumerable_Comparer_Should_ReturnFalse()
+        {
+            // Assign
+            var type = "System.Collections.Comparer";
+
+            // Act
+            var result = type.IsEnumerable();
+
+            // Assert
+            result.Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void IsEnumerable_StructuralComparisons_Should_ReturnFalse()
+        {
+            // Assign
+            var type = "System.Collections.StructuralComparisons";
+
+            // Act
+            var result = type.IsEnumerable();
+
+            // Assert
+            result.Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void IsEnumerable_Object_Should_ReturnFalse()
+        {
+            // Assign
+            var type = "System.Object";
+
+            // Act
+            var result = type.IsEnumerable();
+
+            // Assert
+            result.Should().BeFalse();
+        }
+    }
+}
diff --git a/tests/LivingDocumentation.RenderExtensions.Tests/StringExtensionsTests.IsGeneric.cs b/tests/LivingDocumentation.RenderExtensions.Tests/StringExtensionsTests.IsGeneric.cs
new file mode 100644
index 0000000..11e685c
--- /dev/null
+++ b/tests/LivingDocumentation.RenderExtensions.Tests/StringExtensionsTests.IsGeneric.cs
@@ -0,0 +1,47 @@
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace LivingDocumentation.RenderExtensions.Tests
+{
+    public partial class StringExtensionsTests
+    {
+        [TestMethod]
+        public void IsGeneric_NonGenericType_Should_ReturnFalse()
+        {
+            // Assign
+            var type = "System.Object";
+
+            // Act
+            var result = type.IsGeneric();
+
+            // Assert
+            result.Should().BeFalse();
+        }
+
+        [TestMethod]
+        public void IsGeneric_GenericType_Should_ReturnTrue()
+        {
+            // Assign
+            var type = "System.Collections.Generic.Dictionary<System.String,System.String>";
+
+            // Act
+            var result = type.IsGeneric();
+
+            // Assert
+            result.Should().BeTrue();
+        }
+
+        [TestMethod]
+        public void IsGeneric_NonGenericEmbeddedType_Should_ReturnFalse()
+        {
+            // Assign
+            var type = "System.Collections.Generic.Dictionary<System.String,System.String>.Enumerator";
+
+            // Act
+            var result = type.IsGeneric();
+
+            // Assert
+            result.Should().BeFalse();
+        }
+    }
+}