From f14bbade3f8a362684446ae9b17a2b2244322727 Mon Sep 17 00:00:00 2001
From: Egil Hansen <egil@assimilated.dk>
Date: Fri, 28 Aug 2020 01:23:24 +0000
Subject: [PATCH 01/11] new test renderer prototype

---
 src/bunit.core/Rendering/NewTestRenderer.cs   | 134 +++++++++
 .../Rendering/Internal/NewHtmlizer.cs         | 282 ++++++++++++++++++
 .../Rendering/NewTestRendererTest.cs          | 142 +++++++++
 .../Rendering/TestRendererTest.cs             |  37 +++
 .../AsyncRenderOfSubComponentDuringInit.razor |  27 ++
 5 files changed, 622 insertions(+)
 create mode 100644 src/bunit.core/Rendering/NewTestRenderer.cs
 create mode 100644 src/bunit.web/Rendering/Internal/NewHtmlizer.cs
 create mode 100644 tests/bunit.core.tests/Rendering/NewTestRendererTest.cs
 create mode 100644 tests/bunit.testassets/SampleComponents/AsyncRenderOfSubComponentDuringInit.razor

diff --git a/src/bunit.core/Rendering/NewTestRenderer.cs b/src/bunit.core/Rendering/NewTestRenderer.cs
new file mode 100644
index 000000000..fdb3e9114
--- /dev/null
+++ b/src/bunit.core/Rendering/NewTestRenderer.cs
@@ -0,0 +1,134 @@
+#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Runtime.ExceptionServices;
+using System.Text;
+using System.Threading.Tasks;
+
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.RenderTree;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+namespace Bunit.Rendering
+{
+	public interface IRenderedComponent
+	{
+		void OnRender(IReadOnlyDictionary<int, ArrayRange<RenderTreeFrame>> currentRenderTree);
+	}
+
+	public interface IRenderedComponentActivator
+	{
+		IRenderedComponent CreateRenderedComponent(int componentId);
+		IRenderedComponent CreateRenderedComponent<T>(int componentId) where T : IComponent;
+	}
+
+	public sealed class NewTestRenderer : Renderer
+	{
+		private readonly ILogger _logger;
+		private readonly IRenderedComponentActivator _activator;
+		private Exception? _unhandledException;
+		private readonly Dictionary<int, IRenderedComponent> _renderedComponents = new Dictionary<int, IRenderedComponent>();
+
+		public override Dispatcher Dispatcher { get; } = Dispatcher.CreateDefault();
+
+		public NewTestRenderer(IRenderedComponentActivator activator, IServiceProvider services, ILoggerFactory loggerFactory) : base(services, loggerFactory)
+		{
+			_logger = loggerFactory.CreateLogger<TestRenderer>();
+			_activator = activator;
+		}
+
+		public T RenderFragment<T>(RenderFragment renderFragment) where T : IRenderedComponent
+		{
+			T renderedComponent = default;
+			var task = Dispatcher.InvokeAsync(() =>
+			{
+				var root = new WrapperComponent(renderFragment);
+				var rootComponentId = AssignRootComponentId(root);
+				renderedComponent = (T)_activator.CreateRenderedComponent(rootComponentId);
+				_renderedComponents.Add(rootComponentId, renderedComponent);
+				root.Render();
+			});
+
+			Debug.Assert(task.IsCompleted, "The render task did not complete as expected");
+			AssertNoUnhandledExceptions();
+
+			return renderedComponent!;
+		}
+
+		public T RenderComponent<T, TComponent>(ComponentParameter[] componentParameters)
+			where T : IRenderedComponent
+			where TComponent : IComponent
+		{
+			T renderedComponent = default;
+			var task = Dispatcher.InvokeAsync(() =>
+			{
+				var root = new WrapperComponent(componentParameters.ToComponentRenderFragment<TComponent>());
+				var rootComponentId = AssignRootComponentId(root);
+				renderedComponent = (T)_activator.CreateRenderedComponent<TComponent>(rootComponentId);
+				_renderedComponents.Add(rootComponentId, renderedComponent);
+				root.Render();
+			});
+
+			Debug.Assert(task.IsCompleted, "The render task did not complete as expected");
+			AssertNoUnhandledExceptions();
+
+			return renderedComponent!;
+		}
+
+		protected override void HandleException(Exception exception)
+			=> _unhandledException = exception;
+
+		protected override Task UpdateDisplayAsync(in RenderBatch renderBatch)
+		{
+			for (var i = 0; i < renderBatch.UpdatedComponents.Count; i++)
+			{
+				ref var update = ref renderBatch.UpdatedComponents.Array[i];
+				var id = update.ComponentId;
+				if (_renderedComponents.TryGetValue(id, out var rc))
+				{
+					var crtf = GetRenderTreeFromRoot(id);
+
+					rc.OnRender(crtf);
+				}
+			}
+
+			return Task.CompletedTask;
+		}
+
+		private Dictionary<int, ArrayRange<RenderTreeFrame>> GetRenderTreeFromRoot(int rootComponentId)
+		{
+			var result = new Dictionary<int, ArrayRange<RenderTreeFrame>>();
+			GetRenderTreeFramesInternal(rootComponentId);
+			return result;
+
+			void GetRenderTreeFramesInternal(int componentId)
+			{
+				var frames = GetCurrentRenderTreeFrames(componentId);
+				result.Add(componentId, frames);
+
+				for (var i = 0; i < frames.Count; i++)
+				{
+					ref var frame = ref frames.Array[i];
+					if (frame.FrameType == RenderTreeFrameType.Component)
+					{
+						GetRenderTreeFramesInternal(frame.ComponentId);
+					}
+				}
+			}
+		}
+
+		private void AssertNoUnhandledExceptions()
+		{
+			if (_unhandledException is { } unhandled)
+			{
+				_unhandledException = null;
+				var evt = new EventId(3, nameof(AssertNoUnhandledExceptions));
+				_logger.LogError(evt, unhandled, $"An unhandled exception happened during rendering: {unhandled.Message}{Environment.NewLine}{unhandled.StackTrace}");
+				ExceptionDispatchInfo.Capture(unhandled).Throw();
+			}
+		}
+	}
+}
diff --git a/src/bunit.web/Rendering/Internal/NewHtmlizer.cs b/src/bunit.web/Rendering/Internal/NewHtmlizer.cs
new file mode 100644
index 000000000..07bb2e9ff
--- /dev/null
+++ b/src/bunit.web/Rendering/Internal/NewHtmlizer.cs
@@ -0,0 +1,282 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Text.Encodings.Web;
+
+using Bunit.Rendering;
+
+using Microsoft.AspNetCore.Components.RenderTree;
+
+namespace Bunit
+{
+	/// <summary>
+	/// This file is based on
+	/// https://source.dot.net/#Microsoft.AspNetCore.Mvc.ViewFeatures/RazorComponents/HtmlRenderer.cs
+	/// </summary>
+	[SuppressMessage("Usage", "BL0006:Do not use RenderTree types", Justification = "<Pending>")]
+	public static class HewHtmlizer
+	{
+		private static readonly HtmlEncoder HtmlEncoder = HtmlEncoder.Default;
+
+		private static readonly HashSet<string> SelfClosingElements = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+		{
+			"area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"
+		};
+
+		private const string BLAZOR_INTERNAL_ATTR_PREFIX = "__internal_";
+		private const string BLAZOR_CSS_SCOPE_ATTR_PREFIX = "b-";
+		public const string BLAZOR_ATTR_PREFIX = "blazor:";
+		public const string ELEMENT_REFERENCE_ATTR_NAME = BLAZOR_ATTR_PREFIX + "elementreference";
+
+		public static bool IsBlazorAttribute(string attributeName)
+			=> attributeName.StartsWith(BLAZOR_ATTR_PREFIX, StringComparison.Ordinal) ||
+			   attributeName.StartsWith(BLAZOR_CSS_SCOPE_ATTR_PREFIX, StringComparison.Ordinal);
+
+		public static string ToBlazorAttribute(string attributeName)
+		{
+			return $"{BLAZOR_ATTR_PREFIX}{attributeName}";
+		}
+
+		public static string GetHtml(int componentId, IReadOnlyDictionary<int, ArrayRange<RenderTreeFrame>> frameSet)
+		{
+			var context = new HtmlRenderingContext(frameSet);
+			var frames = context.GetRenderTreeFrames(componentId);
+			var newPosition = RenderFrames(context, frames, 0, frames.Count);
+			Debug.Assert(newPosition == frames.Count, $"frames.Count = {frames.Count}. newPosition = {newPosition}");
+			return string.Join(string.Empty, context.Result);
+		}
+
+		private static int RenderFrames(HtmlRenderingContext context, ArrayRange<RenderTreeFrame> frames, int position, int maxElements)
+		{
+			var nextPosition = position;
+			var endPosition = position + maxElements;
+			while (position < endPosition)
+			{
+				nextPosition = RenderCore(context, frames, position);
+				if (position == nextPosition)
+				{
+					throw new InvalidOperationException("We didn't consume any input.");
+				}
+				position = nextPosition;
+			}
+
+			return nextPosition;
+		}
+
+		private static int RenderCore(
+			HtmlRenderingContext context,
+			ArrayRange<RenderTreeFrame> frames,
+			int position)
+		{
+			ref var frame = ref frames.Array[position];
+			switch (frame.FrameType)
+			{
+				case RenderTreeFrameType.Element:
+					return RenderElement(context, frames, position);
+				case RenderTreeFrameType.Attribute:
+					throw new InvalidOperationException($"Attributes should only be encountered within {nameof(RenderElement)}");
+				case RenderTreeFrameType.Text:
+					context.Result.Add(HtmlEncoder.Encode(frame.TextContent));
+					return ++position;
+				case RenderTreeFrameType.Markup:
+					context.Result.Add(frame.MarkupContent);
+					return ++position;
+				case RenderTreeFrameType.Component:
+					return RenderChildComponent(context, frames, position);
+				case RenderTreeFrameType.Region:
+					return RenderFrames(context, frames, position + 1, frame.RegionSubtreeLength - 1);
+				case RenderTreeFrameType.ElementReferenceCapture:
+				case RenderTreeFrameType.ComponentReferenceCapture:
+					return ++position;
+				default:
+					throw new InvalidOperationException($"Invalid element frame type '{frame.FrameType}'.");
+			}
+		}
+
+		private static int RenderChildComponent(
+			HtmlRenderingContext context,
+			ArrayRange<RenderTreeFrame> frames,
+			int position)
+		{
+			ref var frame = ref frames.Array[position];
+			var childFrames = context.GetRenderTreeFrames(frame.ComponentId);
+			RenderFrames(context, childFrames, 0, childFrames.Count);
+			return position + frame.ComponentSubtreeLength;
+		}
+
+		private static int RenderElement(
+			HtmlRenderingContext context,
+			ArrayRange<RenderTreeFrame> frames,
+			int position)
+		{
+			ref var frame = ref frames.Array[position];
+			var result = context.Result;
+			result.Add("<");
+			result.Add(frame.ElementName);
+			var afterAttributes = RenderAttributes(context, frames, position + 1, frame.ElementSubtreeLength - 1, out var capturedValueAttribute);
+
+			// When we see an <option> as a descendant of a <select>, and the option's "value" attribute matches the
+			// "value" attribute on the <select>, then we auto-add the "selected" attribute to that option. This is
+			// a way of converting Blazor's select binding feature to regular static HTML.
+			if (context.ClosestSelectValueAsString != null
+				&& string.Equals(frame.ElementName, "option", StringComparison.OrdinalIgnoreCase)
+				&& string.Equals(capturedValueAttribute, context.ClosestSelectValueAsString, StringComparison.Ordinal))
+			{
+				result.Add(" selected");
+			}
+
+			var remainingElements = frame.ElementSubtreeLength + position - afterAttributes;
+			if (remainingElements > 0)
+			{
+				result.Add(">");
+
+				var isSelect = string.Equals(frame.ElementName, "select", StringComparison.OrdinalIgnoreCase);
+				if (isSelect)
+				{
+					context.ClosestSelectValueAsString = capturedValueAttribute;
+				}
+
+				var afterElement = RenderChildren(context, frames, afterAttributes, remainingElements);
+
+				if (isSelect)
+				{
+					// There's no concept of nested <select> elements, so as soon as we're exiting one of them,
+					// we can safely say there is no longer any value for this
+					context.ClosestSelectValueAsString = null;
+				}
+
+				result.Add("</");
+				result.Add(frame.ElementName);
+				result.Add(">");
+				Debug.Assert(afterElement == position + frame.ElementSubtreeLength);
+				return afterElement;
+			}
+			else
+			{
+				if (SelfClosingElements.Contains(frame.ElementName))
+				{
+					result.Add(" />");
+				}
+				else
+				{
+					result.Add(">");
+					result.Add("</");
+					result.Add(frame.ElementName);
+					result.Add(">");
+				}
+				Debug.Assert(afterAttributes == position + frame.ElementSubtreeLength, $"afterAttributes = {afterAttributes}. position = {position}. frame.ElementSubtreeLength = {frame.ElementSubtreeLength}");
+				return afterAttributes;
+			}
+		}
+
+		private static int RenderChildren(HtmlRenderingContext context, ArrayRange<RenderTreeFrame> frames, int position, int maxElements)
+		{
+			if (maxElements == 0)
+			{
+				return position;
+			}
+
+			return RenderFrames(context, frames, position, maxElements);
+		}
+
+		private static int RenderAttributes(
+			HtmlRenderingContext context,
+			ArrayRange<RenderTreeFrame> frames, int position, int maxElements, out string? capturedValueAttribute)
+		{
+			capturedValueAttribute = null;
+
+			if (maxElements == 0)
+			{
+				return position;
+			}
+
+			var result = context.Result;
+
+			for (var i = 0; i < maxElements; i++)
+			{
+				var candidateIndex = position + i;
+				ref var frame = ref frames.Array[candidateIndex];
+
+				// Added to write ElementReferenceCaptureId to DOM
+				if (frame.FrameType == RenderTreeFrameType.ElementReferenceCapture)
+				{
+					result.Add($" {ELEMENT_REFERENCE_ATTR_NAME}=\"{frame.ElementReferenceCaptureId}\"");
+				}
+
+				if (frame.FrameType != RenderTreeFrameType.Attribute)
+				{
+					return candidateIndex;
+				}
+
+				if (frame.AttributeName.Equals("value", StringComparison.OrdinalIgnoreCase))
+				{
+					capturedValueAttribute = frame.AttributeValue as string;
+				}
+
+				if (frame.AttributeEventHandlerId > 0)
+				{
+					// NOTE: this was changed from  
+					//       result.Add($" {frame.AttributeName}=\"{frame.AttributeEventHandlerId}\"");
+					//       to the following to make it more obvious
+					//       that this is a generated/special blazor attribute
+					//       used for tracking event handler id's
+					result.Add(" ");
+					result.Add(BLAZOR_ATTR_PREFIX);
+					result.Add(frame.AttributeName);
+					result.Add("=");
+					result.Add("\"");
+					result.Add(frame.AttributeEventHandlerId.ToString(CultureInfo.InvariantCulture));
+					result.Add("\"");
+					continue;
+				}
+
+				switch (frame.AttributeValue)
+				{
+					case bool flag when flag && frame.AttributeName.StartsWith(BLAZOR_INTERNAL_ATTR_PREFIX, StringComparison.Ordinal):
+						// NOTE: This was added to make it more obvious
+						//       that this is a generated/special blazor attribute
+						//	     for internal usage                    
+						result.Add(" ");
+						result.Add(BLAZOR_ATTR_PREFIX);
+						result.Add(frame.AttributeName);
+						break;
+					case bool flag when flag:
+						result.Add(" ");
+						result.Add(frame.AttributeName);
+						break;
+					case string value:
+						result.Add(" ");
+						result.Add(frame.AttributeName);
+						result.Add("=");
+						result.Add("\"");
+						result.Add(HtmlEncoder.Encode(value));
+						result.Add("\"");
+						break;
+					default:
+						break;
+				}
+			}
+
+			return position + maxElements;
+		}
+
+		private class HtmlRenderingContext
+		{
+			private readonly IReadOnlyDictionary<int, ArrayRange<RenderTreeFrame>> _frames;
+
+			public HtmlRenderingContext(IReadOnlyDictionary<int, ArrayRange<RenderTreeFrame>> frames)
+			{
+				_frames = frames;
+			}
+
+			public ArrayRange<RenderTreeFrame> GetRenderTreeFrames(int componentId)
+				=> _frames[componentId];
+
+			public List<string> Result { get; } = new List<string>();
+
+			public string? ClosestSelectValueAsString { get; set; }
+		}
+	}
+}
diff --git a/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs b/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs
new file mode 100644
index 000000000..8f12296c0
--- /dev/null
+++ b/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs
@@ -0,0 +1,142 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Bunit.Rendering;
+
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Rendering;
+using Microsoft.AspNetCore.Components.RenderTree;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+
+using Shouldly;
+
+using Xunit;
+
+namespace Bunit.Rendering
+{
+	public class NoChildNoParams : ComponentBase
+	{
+		public const string MARKUP = "<h1>hello world</h1>";
+		protected override void BuildRenderTree(RenderTreeBuilder builder)
+			=> builder.AddMarkupContent(0, MARKUP);
+	}
+
+	internal class TestRenderedFragment : IRenderedComponent
+	{
+		private readonly object _renderLock = new object();
+
+		protected int ComponentId { get; set; }
+
+		public string Markup { get; private set; } = string.Empty;
+
+		public int RenderCount { get; private set; }
+
+		public TestRenderedFragment(int componentId)
+		{
+			ComponentId = componentId;
+		}
+
+		void IRenderedComponent.OnRender(IReadOnlyDictionary<int, ArrayRange<RenderTreeFrame>> currentRenderTree)
+		{
+			lock (_renderLock)
+			{
+				OnRender(currentRenderTree);
+				RenderCount++;
+				Markup = HewHtmlizer.GetHtml(ComponentId, currentRenderTree);
+			}
+		}
+
+		protected virtual void OnRender(IReadOnlyDictionary<int, ArrayRange<RenderTreeFrame>> currentRenderTree) { }
+	}
+
+	internal class TestRenderedComponent<TComponent> : TestRenderedFragment where TComponent : IComponent
+	{
+		private TComponent _instance = default!;
+
+		public TComponent Instance => _instance ?? throw new InvalidOperationException("Component has not rendered yet...");
+
+		public TestRenderedComponent(int componentId) : base(componentId)
+		{
+		}
+
+		protected override void OnRender(IReadOnlyDictionary<int, ArrayRange<RenderTreeFrame>> currentRenderTree)
+		{
+			if (_instance is null)
+			{
+				var frames = currentRenderTree[ComponentId];
+				if (frames.Array[0].Component is TComponent wrapperComponent)
+				{
+					_instance = wrapperComponent;
+					ComponentId = frames.Array[0].ComponentId;
+				}
+				else
+				{
+					throw new InvalidOperationException("Component instance not found at expected position in render tree.");
+				}
+			}
+		}
+	}
+
+	internal sealed class TestRenderedComponentActivator : IRenderedComponentActivator
+	{
+		public IRenderedComponent CreateRenderedComponent<T>(int componentId) where T : IComponent
+			=> new TestRenderedComponent<T>(componentId);
+		public IRenderedComponent CreateRenderedComponent(int componentId)
+			=> new TestRenderedFragment(componentId);
+	}
+
+	public class NewTestRendererTest
+	{
+		private ILoggerFactory LoggerFactory { get; } = NullLoggerFactory.Instance;
+		private TestServiceProvider Services { get; } = new TestServiceProvider();
+		private IRenderedComponentActivator Activator { get; } = new TestRenderedComponentActivator();
+
+		[Fact(DisplayName = "Can render fragment without children and no parameters")]
+		public void Test001()
+		{
+			const string MARKUP = "<h1>hello world</h1>";
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+
+			var cut = sut.RenderFragment<TestRenderedFragment>(builder => builder.AddMarkupContent(0, MARKUP));
+
+			cut.RenderCount.ShouldBe(1);
+			cut.Markup.ShouldBe(MARKUP);
+		}
+
+		[Fact(DisplayName = "Can render component without children and no parameters")]
+		public void Test002()
+		{
+			const string MARKUP = "<h1>hello world</h1>";
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+
+			var cut = sut.RenderComponent<TestRenderedComponent<NoChildNoParams>, NoChildNoParams>(Array.Empty<ComponentParameter>());
+
+			cut.RenderCount.ShouldBe(1);
+			cut.Markup.ShouldBe(MARKUP);
+			cut.Instance.ShouldBeOfType<NoChildNoParams>();
+		}
+
+		// renderer rethrows unhandled exceptions
+
+		// rendered fragment updates RenderCount on rerenders
+		// rendered component updates RenderCount on rerenders
+
+		// rendered fragment updates RenderCount, markup on rerenders with changes in render tree
+		// rendered component updates RenderCount, markup on rerenders with changes in render tree
+
+		// rendered fragment updates RenderCount, markup on rerenders from child components with changes in render tree
+		// rendered component updates RenderCount, markup on rerenders from child components with changes in render tree
+
+		// rendered fragment updates RenderCount, markup on rerenders when child components are disposed
+		// rendered component updates RenderCount, markup on rerenders when child components are disposed
+
+		// rendered fragment marked as disposed when it is removed from render tree
+		// rendered component marked as disposed when it is removed from render tree
+
+		// GetComponent (FindCompnent) and GetComponents (FindComponents) tests....
+	}
+}
diff --git a/tests/bunit.core.tests/Rendering/TestRendererTest.cs b/tests/bunit.core.tests/Rendering/TestRendererTest.cs
index 71fa31491..f5967cce9 100644
--- a/tests/bunit.core.tests/Rendering/TestRendererTest.cs
+++ b/tests/bunit.core.tests/Rendering/TestRendererTest.cs
@@ -70,6 +70,43 @@ public void Test003()
 			handler2.ReceivedEvents.Count.ShouldBe(1);
 		}
 
+		[Fact(DisplayName = "Can render component that awaits uncompleted task in OnInitializedAsync")]
+		public void Test100()
+		{
+			using var ctx = new TestContext();
+			var tcs = new TaskCompletionSource<object>();
+
+			var cut = ctx.RenderComponent<AsyncRenderOfSubComponentDuringInit>(parameters =>
+				parameters.Add(p => p.EitherOr, tcs.Task)
+			);
+
+			cut.Find("h1").TextContent.ShouldBe("FIRST");
+		}
+
+		[Fact(DisplayName = "Can render component that awaits yielding task in OnInitializedAsync")]
+		public void Test101()
+		{
+			using var ctx = new TestContext();
+
+			var cut = ctx.RenderComponent<AsyncRenderOfSubComponentDuringInit>(parameters =>
+				parameters.Add(p => p.EitherOr, Task.Delay(1))
+			);
+
+			cut.Find("h1").TextContent.ShouldBe("FIRST");
+		}
+
+		[Fact(DisplayName = "Can render component that awaits completed task in OnInitializedAsync")]
+		public void Test102()
+		{
+			using var ctx = new TestContext();
+
+			var cut = ctx.RenderComponent<AsyncRenderOfSubComponentDuringInit>(parameters =>
+				parameters.Add(p => p.EitherOr, Task.CompletedTask)
+			);
+
+			cut.Find("h1").TextContent.ShouldBe("SECOND");
+		}
+
 		class MockRenderEventHandler : IRenderEventHandler
 		{
 			private TaskCompletionSource<object?> _handleTask = new TaskCompletionSource<object?>();
diff --git a/tests/bunit.testassets/SampleComponents/AsyncRenderOfSubComponentDuringInit.razor b/tests/bunit.testassets/SampleComponents/AsyncRenderOfSubComponentDuringInit.razor
new file mode 100644
index 000000000..819bfd7df
--- /dev/null
+++ b/tests/bunit.testassets/SampleComponents/AsyncRenderOfSubComponentDuringInit.razor
@@ -0,0 +1,27 @@
+<Wrapper>
+	@if (_eitherOr)
+	{
+		<Wrapper>
+			<Simple1 Header="FIRST" />
+		</Wrapper>
+	}
+	else
+	{
+		<Wrapper>
+			<Simple1 Header="SECOND" />
+		</Wrapper>
+	}
+</Wrapper>
+
+@code
+{
+	private bool _eitherOr = true;
+
+	[Parameter] public Task EitherOr { get; set; }
+
+	protected override async Task OnInitializedAsync()
+	{
+		await EitherOr;
+		_eitherOr = false;
+	}
+}

From 140f4348948509a6aeac5b843dbf00d409d72b69 Mon Sep 17 00:00:00 2001
From: Egil Hansen <egil@assimilated.dk>
Date: Fri, 28 Aug 2020 22:09:20 +0000
Subject: [PATCH 02/11] new test renderer prototype done

---
 src/bunit.core/Rendering/NewRenderEvent.cs    | 108 +++++
 src/bunit.core/Rendering/NewTestRenderer.cs   | 197 ++++++--
 .../Rendering/Internal/NewHtmlizer.cs         |   8 +-
 .../Rendering/NewTestRendererTest.cs          | 451 ++++++++++++++++--
 4 files changed, 693 insertions(+), 71 deletions(-)
 create mode 100644 src/bunit.core/Rendering/NewRenderEvent.cs

diff --git a/src/bunit.core/Rendering/NewRenderEvent.cs b/src/bunit.core/Rendering/NewRenderEvent.cs
new file mode 100644
index 000000000..509dafb10
--- /dev/null
+++ b/src/bunit.core/Rendering/NewRenderEvent.cs
@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using Microsoft.AspNetCore.Components.RenderTree;
+
+namespace Bunit.Rendering
+{
+	public sealed class RenderTreeFrameCollection
+	{
+		private Dictionary<int, ArrayRange<RenderTreeFrame>> _currentRenderTree = new Dictionary<int, ArrayRange<RenderTreeFrame>>();
+
+		public ArrayRange<RenderTreeFrame> this[int componentId] => _currentRenderTree[componentId];
+
+		internal RenderTreeFrameCollection() { }
+
+		public bool Contains(int componentId) => _currentRenderTree.ContainsKey(componentId);
+
+		internal void Add(int componentId, ArrayRange<RenderTreeFrame> frames) => _currentRenderTree.Add(componentId, frames);
+	}
+
+	public sealed class NewRenderEvent
+	{
+		private readonly RenderBatch _renderBatch;
+
+		public RenderTreeFrameCollection Frames { get; }
+
+		internal NewRenderEvent(RenderBatch renderBatch, RenderTreeFrameCollection frames)
+		{
+			_renderBatch = renderBatch;
+			Frames = frames;
+		}
+
+		public (bool rendered, bool changed, bool disposed) GetRenderStatus(IRenderedComponent renderedComponent)
+		{
+			if (renderedComponent is null)
+				throw new ArgumentNullException(nameof(renderedComponent));
+
+			var result = (rendered: false, changed: false, disposed: false);
+
+			if (DidComponentDispose(renderedComponent))
+			{
+				result.disposed = true;
+			}
+			else
+			{
+				(result.rendered, result.changed) = GetRenderAndChangeStatus(renderedComponent);
+			}
+
+			return result;
+		}
+
+		private bool DidComponentDispose(IRenderedComponent renderedComponent)
+		{
+			for (var i = 0; i < _renderBatch.DisposedComponentIDs.Count; i++)
+				if (_renderBatch.DisposedComponentIDs.Array[i].Equals(renderedComponent.ComponentId))
+					return true;
+
+			return false;
+		}
+
+		private (bool rendered, bool hasChanges) GetRenderAndChangeStatus(IRenderedComponent renderedComponent)
+		{
+			var result = (rendered: false, hasChanges: false);
+
+			GetStatus(renderedComponent.ComponentId);
+
+			return result;
+
+			void GetStatus(int componentId)
+			{
+				for (var i = 0; i < _renderBatch.UpdatedComponents.Count; i++)
+				{
+					ref var update = ref _renderBatch.UpdatedComponents.Array[i];
+					if (update.ComponentId == componentId)
+					{
+						result.rendered = true;
+						result.hasChanges = update.Edits.Count > 0;
+						break;
+					}
+				}
+
+				if (!result.hasChanges)
+				{
+					GetStatusFromChildren(componentId);
+				}
+			}
+
+			void GetStatusFromChildren(int componentId)
+			{
+				var frames = Frames[componentId];
+				for (var i = 0; i < frames.Count; i++)
+				{
+					ref var frame = ref frames.Array[i];
+					if (frame.FrameType == RenderTreeFrameType.Component)
+					{
+						GetStatus(frame.ComponentId);
+
+						if (result.hasChanges)
+						{
+							break;
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/src/bunit.core/Rendering/NewTestRenderer.cs b/src/bunit.core/Rendering/NewTestRenderer.cs
index fdb3e9114..cd8a4be05 100644
--- a/src/bunit.core/Rendering/NewTestRenderer.cs
+++ b/src/bunit.core/Rendering/NewTestRenderer.cs
@@ -1,4 +1,3 @@
-#pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -14,19 +13,25 @@
 
 namespace Bunit.Rendering
 {
-	public interface IRenderedComponent
+	public interface IRenderedComponent : IDisposable
 	{
-		void OnRender(IReadOnlyDictionary<int, ArrayRange<RenderTreeFrame>> currentRenderTree);
+		bool IsDisposed { get; }
+
+		int ComponentId { get; }
+
+		void OnRender(NewRenderEvent renderEvent);
 	}
 
 	public interface IRenderedComponentActivator
 	{
 		IRenderedComponent CreateRenderedComponent(int componentId);
 		IRenderedComponent CreateRenderedComponent<T>(int componentId) where T : IComponent;
+		IRenderedComponent CreateRenderedComponent<T>(int componentId, T component, RenderTreeFrameCollection componentFrames) where T : IComponent;
 	}
 
 	public sealed class NewTestRenderer : Renderer
 	{
+		private readonly object _renderTreeAccessLock = new object();
 		private readonly ILogger _logger;
 		private readonly IRenderedComponentActivator _activator;
 		private Exception? _unhandledException;
@@ -40,14 +45,14 @@ public NewTestRenderer(IRenderedComponentActivator activator, IServiceProvider s
 			_activator = activator;
 		}
 
-		public T RenderFragment<T>(RenderFragment renderFragment) where T : IRenderedComponent
+		public IRenderedComponent RenderFragment(RenderFragment renderFragment)
 		{
-			T renderedComponent = default;
+			IRenderedComponent renderedComponent = default!;
 			var task = Dispatcher.InvokeAsync(() =>
 			{
 				var root = new WrapperComponent(renderFragment);
 				var rootComponentId = AssignRootComponentId(root);
-				renderedComponent = (T)_activator.CreateRenderedComponent(rootComponentId);
+				renderedComponent = _activator.CreateRenderedComponent(rootComponentId);
 				_renderedComponents.Add(rootComponentId, renderedComponent);
 				root.Render();
 			});
@@ -58,16 +63,15 @@ public T RenderFragment<T>(RenderFragment renderFragment) where T : IRenderedCom
 			return renderedComponent!;
 		}
 
-		public T RenderComponent<T, TComponent>(ComponentParameter[] componentParameters)
-			where T : IRenderedComponent
+		public IRenderedComponent RenderComponent<TComponent>(IEnumerable<ComponentParameter> componentParameters)
 			where TComponent : IComponent
 		{
-			T renderedComponent = default;
+			IRenderedComponent renderedComponent = default!;
 			var task = Dispatcher.InvokeAsync(() =>
 			{
 				var root = new WrapperComponent(componentParameters.ToComponentRenderFragment<TComponent>());
 				var rootComponentId = AssignRootComponentId(root);
-				renderedComponent = (T)_activator.CreateRenderedComponent<TComponent>(rootComponentId);
+				renderedComponent = _activator.CreateRenderedComponent<TComponent>(rootComponentId);
 				_renderedComponents.Add(rootComponentId, renderedComponent);
 				root.Render();
 			});
@@ -78,48 +82,185 @@ public T RenderComponent<T, TComponent>(ComponentParameter[] componentParameters
 			return renderedComponent!;
 		}
 
-		protected override void HandleException(Exception exception)
-			=> _unhandledException = exception;
 
-		protected override Task UpdateDisplayAsync(in RenderBatch renderBatch)
+		public IRenderedComponent FindComponent<TComponent>(IRenderedComponent parentComponent)
+			where TComponent : IComponent
 		{
-			for (var i = 0; i < renderBatch.UpdatedComponents.Count; i++)
+			if (parentComponent is null)
+				throw new ArgumentNullException(nameof(parentComponent));
+
+			var framesCollection = new RenderTreeFrameCollection();
+
+			lock (_renderTreeAccessLock)
 			{
-				ref var update = ref renderBatch.UpdatedComponents.Array[i];
-				var id = update.ComponentId;
-				if (_renderedComponents.TryGetValue(id, out var rc))
+				if (TryFindComponent(parentComponent.ComponentId, out var id, out var component))
 				{
-					var crtf = GetRenderTreeFromRoot(id);
-
-					rc.OnRender(crtf);
+					LoadRenderTreeFrames(id, framesCollection);
+					var rc = _activator.CreateRenderedComponent(id, component, framesCollection);
+					_renderedComponents.Add(rc.ComponentId, rc);
+					return rc;
+				}
+				else
+				{
+					throw new ComponentNotFoundException(typeof(TComponent));
 				}
 			}
 
-			return Task.CompletedTask;
+			bool TryFindComponent(int parentComponentId, out int componentId, out TComponent component)
+			{
+				var result = false;
+				componentId = -1;
+				component = default!;
+
+				var frames = LoadAndGetRenderTreeFrame(framesCollection, parentComponentId);
+
+				for (var i = 0; i < frames.Count; i++)
+				{
+					ref var frame = ref frames.Array[i];
+					if (frame.FrameType == RenderTreeFrameType.Component)
+					{
+						if (frame.Component is TComponent c)
+						{
+							componentId = frame.ComponentId;
+							component = c;
+							result = true;
+							break;
+						}
+
+						if (TryFindComponent(frame.ComponentId, out componentId, out component))
+						{
+							result = true;
+							break;
+						}
+					}
+				}
+
+				return result;
+			}
 		}
 
-		private Dictionary<int, ArrayRange<RenderTreeFrame>> GetRenderTreeFromRoot(int rootComponentId)
+		public IReadOnlyList<IRenderedComponent> FindComponents<TComponent>(IRenderedComponent parentComponent)
+			where TComponent : IComponent
 		{
-			var result = new Dictionary<int, ArrayRange<RenderTreeFrame>>();
-			GetRenderTreeFramesInternal(rootComponentId);
+			if (parentComponent is null)
+				throw new ArgumentNullException(nameof(parentComponent));
+
+			var result = new List<IRenderedComponent>();
+			var framesCollection = new RenderTreeFrameCollection();
+
+			lock (_renderTreeAccessLock)
+			{
+				FindComponentsInternal(parentComponent.ComponentId);
+				foreach (var rc in result)
+				{
+					_renderedComponents.Add(rc.ComponentId, rc);
+				}
+			}
+
 			return result;
 
-			void GetRenderTreeFramesInternal(int componentId)
+			void FindComponentsInternal(int componentId)
 			{
-				var frames = GetCurrentRenderTreeFrames(componentId);
-				result.Add(componentId, frames);
+				var frames = LoadAndGetRenderTreeFrame(framesCollection, componentId);
 
 				for (var i = 0; i < frames.Count; i++)
 				{
 					ref var frame = ref frames.Array[i];
 					if (frame.FrameType == RenderTreeFrameType.Component)
 					{
-						GetRenderTreeFramesInternal(frame.ComponentId);
+						if (frame.Component is TComponent component)
+						{
+							var id = frame.ComponentId;
+							LoadRenderTreeFrames(id, framesCollection);
+							var rc = _activator.CreateRenderedComponent(id, component, framesCollection);
+							result.Add(rc);
+						}
+
+						FindComponentsInternal(frame.ComponentId);
 					}
 				}
 			}
 		}
 
+		/// <inheritdoc/>
+		protected override void ProcessPendingRender()
+		{
+			lock (_renderTreeAccessLock)
+			{
+				base.ProcessPendingRender();
+			}
+		}
+
+		/// <inheritdoc/>
+		protected override void HandleException(Exception exception)
+			=> _unhandledException = exception;
+
+		/// <inheritdoc/>
+		protected override Task UpdateDisplayAsync(in RenderBatch renderBatch)
+		{
+			var renderEvent = new NewRenderEvent(renderBatch, new RenderTreeFrameCollection());
+
+			// removes disposed components
+			for (var i = 0; i < renderBatch.DisposedComponentIDs.Count; i++)
+			{
+				var id = renderBatch.DisposedComponentIDs.Array[i];
+				if (_renderedComponents.TryGetValue(id, out var rc))
+				{
+					_renderedComponents.Remove(id);
+					rc.OnRender(renderEvent);
+				}
+			}
+
+			foreach (var (key, rc) in _renderedComponents.ToArray())
+			{
+				LoadRenderTreeFrames(rc.ComponentId, renderEvent.Frames);
+				rc.OnRender(renderEvent);
+
+				// RC can replace the instance of the component is bound
+				// to while processing the update event. 
+				if (key != rc.ComponentId)
+				{
+					_renderedComponents.Remove(key);
+					_renderedComponents.Add(rc.ComponentId, rc);
+				}
+			}
+
+			return Task.CompletedTask;
+		}
+
+		protected override void Dispose(bool disposing)
+		{
+			foreach (var rc in _renderedComponents.Values)
+			{
+				rc.Dispose();
+			}
+			base.Dispose(disposing);
+		}
+
+		private void LoadRenderTreeFrames(int componentId, RenderTreeFrameCollection framesCollection)
+		{
+			var frames = LoadAndGetRenderTreeFrame(framesCollection, componentId);
+
+			for (var i = 0; i < frames.Count; i++)
+			{
+				ref var frame = ref frames.Array[i];
+				if (frame.FrameType == RenderTreeFrameType.Component)
+				{
+					LoadRenderTreeFrames(frame.ComponentId, framesCollection);
+				}
+			}
+		}
+
+		private ArrayRange<RenderTreeFrame> LoadAndGetRenderTreeFrame(RenderTreeFrameCollection framesCollection, int componentId)
+		{
+			if (!framesCollection.Contains(componentId))
+			{
+				framesCollection.Add(componentId, GetCurrentRenderTreeFrames(componentId));
+			}
+
+			return framesCollection[componentId];
+		}
+
 		private void AssertNoUnhandledExceptions()
 		{
 			if (_unhandledException is { } unhandled)
diff --git a/src/bunit.web/Rendering/Internal/NewHtmlizer.cs b/src/bunit.web/Rendering/Internal/NewHtmlizer.cs
index 07bb2e9ff..495fc8a96 100644
--- a/src/bunit.web/Rendering/Internal/NewHtmlizer.cs
+++ b/src/bunit.web/Rendering/Internal/NewHtmlizer.cs
@@ -39,9 +39,9 @@ public static string ToBlazorAttribute(string attributeName)
 			return $"{BLAZOR_ATTR_PREFIX}{attributeName}";
 		}
 
-		public static string GetHtml(int componentId, IReadOnlyDictionary<int, ArrayRange<RenderTreeFrame>> frameSet)
+		public static string GetHtml(int componentId, RenderTreeFrameCollection framesCollection)
 		{
-			var context = new HtmlRenderingContext(frameSet);
+			var context = new HtmlRenderingContext(framesCollection);
 			var frames = context.GetRenderTreeFrames(componentId);
 			var newPosition = RenderFrames(context, frames, 0, frames.Count);
 			Debug.Assert(newPosition == frames.Count, $"frames.Count = {frames.Count}. newPosition = {newPosition}");
@@ -264,9 +264,9 @@ private static int RenderAttributes(
 
 		private class HtmlRenderingContext
 		{
-			private readonly IReadOnlyDictionary<int, ArrayRange<RenderTreeFrame>> _frames;
+			private readonly RenderTreeFrameCollection _frames;
 
-			public HtmlRenderingContext(IReadOnlyDictionary<int, ArrayRange<RenderTreeFrame>> frames)
+			public HtmlRenderingContext(RenderTreeFrameCollection frames)
 			{
 				_frames = frames;
 			}
diff --git a/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs b/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs
index 8f12296c0..fa9a61597 100644
--- a/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs
+++ b/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs
@@ -13,44 +13,145 @@
 using Microsoft.Extensions.Logging.Abstractions;
 
 using Shouldly;
-
+using static Bunit.ComponentParameterFactory;
 using Xunit;
 
 namespace Bunit.Rendering
 {
 	public class NoChildNoParams : ComponentBase
 	{
-		public const string MARKUP = "<h1>hello world</h1>";
+		public const string MARKUP = "hello world";
 		protected override void BuildRenderTree(RenderTreeBuilder builder)
 			=> builder.AddMarkupContent(0, MARKUP);
 	}
 
+	public class ThrowsDuringSetParams : ComponentBase
+	{
+		public static readonly InvalidOperationException EXCEPTION =
+			new InvalidOperationException("THROWS ON PURPOSE");
+
+		public override Task SetParametersAsync(ParameterView parameters) => throw EXCEPTION;
+	}
+
+	public class HasParams : ComponentBase
+	{
+		[Parameter] public string? Value { get; set; }
+		[Parameter] public RenderFragment? ChildContent { get; set; }
+
+		protected override void BuildRenderTree(RenderTreeBuilder builder)
+		{
+			builder.AddMarkupContent(0, Value);
+			builder.AddContent(1, ChildContent);
+		}
+	}
+
+	public class RenderTrigger : ComponentBase
+	{
+		[Parameter] public string? Value { get; set; }
+
+		public Task Trigger() => InvokeAsync(StateHasChanged);
+		public Task TriggerWithValue(string value)
+		{
+			Value = value;
+			return InvokeAsync(StateHasChanged);
+		}
+
+		protected override void BuildRenderTree(RenderTreeBuilder builder)
+		{
+			builder.AddMarkupContent(0, Value);
+		}
+	}
+
+	public class ToggleChild : ComponentBase
+	{
+		private bool _showing = true;
+
+		[Parameter] public RenderFragment? ChildContent { get; set; }
+
+		public Task DisposeChild()
+		{
+			_showing = false;
+			return InvokeAsync(StateHasChanged);
+		}
+
+		protected override void BuildRenderTree(RenderTreeBuilder builder)
+		{
+			if (_showing)
+				builder.AddContent(0, ChildContent);
+		}
+	}
+
 	internal class TestRenderedFragment : IRenderedComponent
 	{
-		private readonly object _renderLock = new object();
+		private readonly object _markupAccessLock = new object();
+		private string _markup = string.Empty;
 
-		protected int ComponentId { get; set; }
+		public bool IsDisposed { get; private set; }
+
+		public int ComponentId { get; protected set; }
+
+		public string Markup
+		{
+			get
+			{
+				if (IsDisposed)
+					throw new ComponentDisposedException(ComponentId);
 
-		public string Markup { get; private set; } = string.Empty;
+				lock (_markupAccessLock)
+				{
+					return _markup;
+				}
+			}
+		}
 
-		public int RenderCount { get; private set; }
+		public int RenderCount { get; protected set; }
 
 		public TestRenderedFragment(int componentId)
 		{
 			ComponentId = componentId;
 		}
 
-		void IRenderedComponent.OnRender(IReadOnlyDictionary<int, ArrayRange<RenderTreeFrame>> currentRenderTree)
+		void IRenderedComponent.OnRender(NewRenderEvent renderEvent)
 		{
-			lock (_renderLock)
+			if (IsDisposed)
+				return;
+
+			lock (_markupAccessLock)
 			{
-				OnRender(currentRenderTree);
-				RenderCount++;
-				Markup = HewHtmlizer.GetHtml(ComponentId, currentRenderTree);
+				var (rendered, changed, disposed) = renderEvent.GetRenderStatus(this);
+
+				if (disposed)
+				{
+					((IDisposable)this).Dispose();
+					return;
+				}
+
+				if (rendered)
+				{
+					OnRender(renderEvent);
+					RenderCount++;
+
+					if (changed)
+						UpdateMarkup(renderEvent.Frames);
+				}
+			}
+		}
+		
+		void IDisposable.Dispose()
+		{
+			IsDisposed = true;
+			_markup = string.Empty;
+		}
+
+		protected void UpdateMarkup(RenderTreeFrameCollection framesCollection)
+		{
+			lock (_markupAccessLock)
+			{
+				_markup = HewHtmlizer.GetHtml(ComponentId, framesCollection);
 			}
 		}
 
-		protected virtual void OnRender(IReadOnlyDictionary<int, ArrayRange<RenderTreeFrame>> currentRenderTree) { }
+		protected virtual void OnRender(NewRenderEvent renderEvent) { }
 	}
 
 	internal class TestRenderedComponent<TComponent> : TestRenderedFragment where TComponent : IComponent
@@ -63,20 +164,32 @@ public TestRenderedComponent(int componentId) : base(componentId)
 		{
 		}
 
-		protected override void OnRender(IReadOnlyDictionary<int, ArrayRange<RenderTreeFrame>> currentRenderTree)
+		public TestRenderedComponent(int componentId, TComponent instance, RenderTreeFrameCollection componentFrames) : base(componentId)
+		{
+			_instance = instance;
+			RenderCount++;
+			UpdateMarkup(componentFrames);
+		}
+
+		protected override void OnRender(NewRenderEvent renderEvent)
 		{
 			if (_instance is null)
 			{
-				var frames = currentRenderTree[ComponentId];
-				if (frames.Array[0].Component is TComponent wrapperComponent)
-				{
-					_instance = wrapperComponent;
-					ComponentId = frames.Array[0].ComponentId;
-				}
-				else
-				{
-					throw new InvalidOperationException("Component instance not found at expected position in render tree.");
-				}
+				SetComponentAndID(renderEvent);
+			}
+		}
+
+		private void SetComponentAndID(NewRenderEvent renderEvent)
+		{
+			var frames = renderEvent.Frames[ComponentId];
+			if (frames.Array[0].Component is TComponent wrapperComponent)
+			{
+				_instance = wrapperComponent;
+				ComponentId = frames.Array[0].ComponentId;
+			}
+			else
+			{
+				throw new InvalidOperationException("Component instance not found at expected position in render tree.");
 			}
 		}
 	}
@@ -87,6 +200,17 @@ public IRenderedComponent CreateRenderedComponent<T>(int componentId) where T :
 			=> new TestRenderedComponent<T>(componentId);
 		public IRenderedComponent CreateRenderedComponent(int componentId)
 			=> new TestRenderedFragment(componentId);
+		public IRenderedComponent CreateRenderedComponent<T>(int componentId, T component, RenderTreeFrameCollection componentFrames) where T : IComponent
+			=> new TestRenderedComponent<T>(componentId, component, componentFrames);
+	}
+
+	internal static class TestRendererExtensions
+	{
+		public static TestRenderedComponent<TComponent> RenderComponent<TComponent>(this NewTestRenderer renderer, params ComponentParameter[] parameters)
+			where TComponent : IComponent
+		{
+			return (TestRenderedComponent<TComponent>)renderer.RenderComponent<TComponent>(parameters);
+		}
 	}
 
 	public class NewTestRendererTest
@@ -95,13 +219,32 @@ public class NewTestRendererTest
 		private TestServiceProvider Services { get; } = new TestServiceProvider();
 		private IRenderedComponentActivator Activator { get; } = new TestRenderedComponentActivator();
 
+		[Fact(DisplayName = "RenderFragment re-throws exception from component")]
+		public void Test004()
+		{
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			RenderFragment thowingFragment = b => { b.OpenComponent<ThrowsDuringSetParams>(0); b.CloseComponent(); };
+
+			Should.Throw<InvalidOperationException>(() => sut.RenderFragment(thowingFragment))
+				.Message.ShouldBe(ThrowsDuringSetParams.EXCEPTION.Message);
+		}
+
+		[Fact(DisplayName = "RenderComponent re-throws exception from component")]
+		public void Test003()
+		{
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+
+			Should.Throw<InvalidOperationException>(() => sut.RenderComponent<ThrowsDuringSetParams>())
+				.Message.ShouldBe(ThrowsDuringSetParams.EXCEPTION.Message);
+		}
+
 		[Fact(DisplayName = "Can render fragment without children and no parameters")]
 		public void Test001()
 		{
 			const string MARKUP = "<h1>hello world</h1>";
 			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
 
-			var cut = sut.RenderFragment<TestRenderedFragment>(builder => builder.AddMarkupContent(0, MARKUP));
+			var cut = (TestRenderedFragment)sut.RenderFragment(builder => builder.AddMarkupContent(0, MARKUP));
 
 			cut.RenderCount.ShouldBe(1);
 			cut.Markup.ShouldBe(MARKUP);
@@ -110,33 +253,263 @@ public void Test001()
 		[Fact(DisplayName = "Can render component without children and no parameters")]
 		public void Test002()
 		{
-			const string MARKUP = "<h1>hello world</h1>";
 			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
 
-			var cut = sut.RenderComponent<TestRenderedComponent<NoChildNoParams>, NoChildNoParams>(Array.Empty<ComponentParameter>());
+			var cut = sut.RenderComponent<NoChildNoParams>();
 
 			cut.RenderCount.ShouldBe(1);
-			cut.Markup.ShouldBe(MARKUP);
+			cut.Markup.ShouldBe(NoChildNoParams.MARKUP);
 			cut.Instance.ShouldBeOfType<NoChildNoParams>();
 		}
 
-		// renderer rethrows unhandled exceptions
+		[Fact(DisplayName = "Can render component with parameters")]
+		public void Test005()
+		{
+			const string VALUE = "FOO BAR";
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+
+			var cut = sut.RenderComponent<HasParams>((nameof(HasParams.Value), VALUE));
+
+			cut.Instance.Value.ShouldBe(VALUE);
+		}
+
+		[Fact(DisplayName = "Can render component with child component")]
+		public void Test006()
+		{
+			const string PARENT_VALUE = "PARENT";
+			const string CHILD_VALUE = "CHILD";
+
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+
+			var cut = sut.RenderComponent<HasParams>(
+				(nameof(HasParams.Value), PARENT_VALUE),
+				ChildContent<HasParams>((nameof(HasParams.Value), CHILD_VALUE))
+			);
+
+			cut.Markup.ShouldStartWith(PARENT_VALUE);
+			cut.Markup.ShouldEndWith(CHILD_VALUE);
+		}
+
+		[Fact(DisplayName = "Rendered component gets RenderCount updated on re-render")]
+		public async Task Test010()
+		{
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+
+			var cut = sut.RenderComponent<RenderTrigger>();
+
+			cut.RenderCount.ShouldBe(1);
+
+			await cut.Instance.Trigger();
+
+			cut.RenderCount.ShouldBe(2);
+		}
+
+		[Fact(DisplayName = "Rendered component gets Markup updated on re-render")]
+		public async Task Test011()
+		{
+			const string EXPECTED = "NOW VALUE";
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+
+			var cut = sut.RenderComponent<RenderTrigger>();
+
+			cut.RenderCount.ShouldBe(1);
+
+			await cut.Instance.TriggerWithValue(EXPECTED);
+
+			cut.RenderCount.ShouldBe(2);
+			cut.Markup.ShouldBe(EXPECTED);
+		}
+
+		[Fact(DisplayName = "FindComponent returns first component nested inside another rendered component")]
+		public void Test020()
+		{
+			// arrange
+			const string PARENT_VALUE = "PARENT";
+			const string CHILD_VALUE = "CHILD";
+
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+
+			var cut = sut.RenderComponent<HasParams>(
+				(nameof(HasParams.Value), PARENT_VALUE),
+				ChildContent<HasParams>((nameof(HasParams.Value), CHILD_VALUE))
+			);
+
+			// act
+			var childCut = (TestRenderedComponent<HasParams>)sut.FindComponent<HasParams>(cut);
+
+			// assert
+			childCut.Markup.ShouldBe(CHILD_VALUE);
+			childCut.RenderCount.ShouldBe(1);
+		}
+
+		[Fact(DisplayName = "FindComponent throws if parentComponent parameter is null")]
+		public void Test021()
+		{
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+
+			Should.Throw<ArgumentNullException>(() => sut.FindComponent<HasParams>(null!));
+		}
+
+		[Fact(DisplayName = "FindComponent throws if component is not found")]
+		public void Test022()
+		{
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var cut = sut.RenderComponent<HasParams>();
+
+			Should.Throw<ComponentNotFoundException>(() => sut.FindComponent<HasParams>(cut));
+		}
+
+		[Fact(DisplayName = "FindComponents returns all components nested inside another rendered component")]
+		public void Test030()
+		{
+			// arrange
+			const string GRAND_PARENT_VALUE = nameof(GRAND_PARENT_VALUE);
+			const string PARENT_VALUE = nameof(PARENT_VALUE);
+			const string CHILD_VALUE = nameof(CHILD_VALUE);
 
-		// rendered fragment updates RenderCount on rerenders
-		// rendered component updates RenderCount on rerenders
 
-		// rendered fragment updates RenderCount, markup on rerenders with changes in render tree
-		// rendered component updates RenderCount, markup on rerenders with changes in render tree
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+
+			var cut = sut.RenderComponent<HasParams>(
+				(nameof(HasParams.Value), GRAND_PARENT_VALUE),
+				ChildContent<HasParams>(
+					(nameof(HasParams.Value), PARENT_VALUE),
+					ChildContent<HasParams>(
+						(nameof(HasParams.Value), CHILD_VALUE)
+					)
+				)
+			);
+
+			// act
+			var childCuts = sut.FindComponents<HasParams>(cut)
+				.Cast<TestRenderedComponent<HasParams>>()
+				.ToArray();
 
-		// rendered fragment updates RenderCount, markup on rerenders from child components with changes in render tree
-		// rendered component updates RenderCount, markup on rerenders from child components with changes in render tree
+			// assert
+			childCuts[0].Markup.ShouldBe(PARENT_VALUE + CHILD_VALUE);
+			childCuts[0].RenderCount.ShouldBe(1);
 
-		// rendered fragment updates RenderCount, markup on rerenders when child components are disposed
-		// rendered component updates RenderCount, markup on rerenders when child components are disposed
+			childCuts[1].Markup.ShouldBe(CHILD_VALUE);
+			childCuts[1].RenderCount.ShouldBe(1);
+		}
 
-		// rendered fragment marked as disposed when it is removed from render tree
-		// rendered component marked as disposed when it is removed from render tree
+		[Fact(DisplayName = "FindComponents throws if parentComponent parameter is null")]
+		public void Test031()
+		{
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
 
-		// GetComponent (FindCompnent) and GetComponents (FindComponents) tests....
+			Should.Throw<ArgumentNullException>(() => sut.FindComponents<HasParams>(null!));
+		}
+
+		[Fact(DisplayName = "Retrieved rendered child component with FindComponent gets updated on re-render")]
+		public async Task Test040()
+		{
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+
+			var parent = sut.RenderComponent<HasParams>(
+				ChildContent<RenderTrigger>()
+			);
+
+			// act
+			var cut = (TestRenderedComponent<RenderTrigger>)sut.FindComponent<RenderTrigger>(parent);
+
+			cut.RenderCount.ShouldBe(1);
+
+			await cut.Instance.TriggerWithValue("X");
+
+			cut.RenderCount.ShouldBe(2);
+			cut.Markup.ShouldBe("X");
+		}
+
+		[Fact(DisplayName = "Retrieved rendered child component with FindComponents gets updated on re-render")]
+		public async Task Test041()
+		{
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+
+			var parent = sut.RenderComponent<HasParams>(
+				ChildContent<RenderTrigger>()
+			);
+
+			// act
+			var cut = (TestRenderedComponent<RenderTrigger>)sut.FindComponents<RenderTrigger>(parent).Single();
+
+			cut.RenderCount.ShouldBe(1);
+
+			await cut.Instance.TriggerWithValue("X");
+
+			cut.RenderCount.ShouldBe(2);
+			cut.Markup.ShouldBe("X");
+		}
+
+		[Fact(DisplayName = "Rendered component updates on re-renders from child components with changes in render tree")]
+		public async Task Test050()
+		{
+			// arrange
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+
+			var cut = sut.RenderComponent<HasParams>(
+				ChildContent<RenderTrigger>()
+			);
+			var child = (TestRenderedComponent<RenderTrigger>)sut.FindComponent<RenderTrigger>(cut);
+
+			// act
+			await child.Instance.TriggerWithValue("X");
+
+			// assert
+			cut.RenderCount.ShouldBe(2);
+			cut.Markup.ShouldBe("X");
+		}
+
+		[Fact(DisplayName = "When component is disposed by renderer, getting Markup throws and IsDisposed returns true")]
+		public async Task Test060()
+		{
+			// arrange
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+
+			var cut = sut.RenderComponent<ToggleChild>(
+				ChildContent<NoChildNoParams>()
+			);
+			var child = (TestRenderedComponent<NoChildNoParams>)sut.FindComponent<NoChildNoParams>(cut);
+
+			// act
+			await cut.Instance.DisposeChild();
+
+			// assert
+			child.IsDisposed.ShouldBeTrue();
+			Should.Throw<ComponentDisposedException>(() => child.Markup);
+		}
+
+		[Fact(DisplayName = "Rendered component updates itself if a child's child is disposed")]
+		public async Task Test061()
+		{
+			// arrange
+			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+
+			var cut = sut.RenderComponent<ToggleChild>(
+				ChildContent<ToggleChild>(
+					ChildContent<NoChildNoParams>()
+				)
+			);
+			var child = (TestRenderedComponent<ToggleChild>)sut.FindComponent<ToggleChild>(cut);
+			var childChild = (TestRenderedComponent<NoChildNoParams>)sut.FindComponent<NoChildNoParams>(cut);
+
+			// act
+			await child.Instance.DisposeChild();
+
+			// assert
+			childChild.IsDisposed.ShouldBeTrue();
+			cut.Markup.ShouldBe(string.Empty);
+		}
+
+		[Fact(DisplayName = "When test renderer is disposed, so is all rendered components")]
+		public void Test070()
+		{
+			TestRenderedComponent<NoChildNoParams> cut;
+			using (var sut = new NewTestRenderer(Activator, Services, LoggerFactory))
+			{
+				cut = sut.RenderComponent<NoChildNoParams>();
+			}
+			cut.IsDisposed.ShouldBeTrue();
+		}
 	}
 }

From adcdcd4d7e3c20761a2a7750d1d6f11ba67ab55e Mon Sep 17 00:00:00 2001
From: Egil Hansen <egil@assimilated.dk>
Date: Sat, 29 Aug 2020 23:18:55 +0000
Subject: [PATCH 03/11] Refactor to new renderer done

---
 bunit.sln                                     |   1 +
 src/Directory.Build.props                     |   4 +-
 .../RenderedComponentInvokeAsyncExtension.cs  |   9 +-
 src/bunit.core/IRenderedFragmentBase.cs       |  28 +-
 .../Rendering/ComponentDisposedException.cs   |   2 +-
 .../Rendering/IRenderEventHandler.cs          |  20 --
 .../Rendering/IRenderEventProducer.cs         |  22 --
 .../Rendering/IRenderedComponentActivator.cs  |  16 +
 src/bunit.core/Rendering/ITestRenderer.cs     |  53 +--
 src/bunit.core/Rendering/NewRenderEvent.cs    | 108 ------
 src/bunit.core/Rendering/NewTestRenderer.cs   | 275 ---------------
 src/bunit.core/Rendering/RenderEvent.cs       | 111 +++---
 .../Rendering/RenderTreeFrameCollection.cs    |  51 +++
 src/bunit.core/Rendering/TestRenderer.cs      | 325 ++++++++++--------
 src/bunit.core/TestContextBase.cs             |   8 +-
 .../Extensions/RenderedFragmentExtensions.cs  |  14 +-
 .../TestServiceProviderExtensions.cs          |   1 +
 src/bunit.web/IRenderedFragment.cs            |  11 +-
 src/bunit.web/RazorTesting/Fixture.cs         |  14 +-
 src/bunit.web/RazorTesting/SnapshotTest.cs    |   8 +-
 src/bunit.web/Rendering/Internal/Htmlizer.cs  |  19 +-
 .../Rendering/Internal/NewHtmlizer.cs         | 282 ---------------
 src/bunit.web/Rendering/RenderedComponent.cs  |  34 +-
 .../Rendering/RenderedComponentActivator.cs   |  29 ++
 src/bunit.web/Rendering/RenderedFragment.cs   | 165 ++++-----
 src/bunit.web/TestContext.cs                  |   8 +-
 .../ComponentParameterFactoryTest.cs          |  16 +-
 .../Rendering/NewTestRendererTest.cs          | 208 +++--------
 .../Rendering/TestRendererTest.cs             |  83 -----
 tests/run-tests.ps1                           |  19 +
 30 files changed, 579 insertions(+), 1365 deletions(-)
 delete mode 100644 src/bunit.core/Rendering/IRenderEventHandler.cs
 delete mode 100644 src/bunit.core/Rendering/IRenderEventProducer.cs
 create mode 100644 src/bunit.core/Rendering/IRenderedComponentActivator.cs
 delete mode 100644 src/bunit.core/Rendering/NewRenderEvent.cs
 delete mode 100644 src/bunit.core/Rendering/NewTestRenderer.cs
 create mode 100644 src/bunit.core/Rendering/RenderTreeFrameCollection.cs
 delete mode 100644 src/bunit.web/Rendering/Internal/NewHtmlizer.cs
 create mode 100644 src/bunit.web/Rendering/RenderedComponentActivator.cs
 create mode 100644 tests/run-tests.ps1

diff --git a/bunit.sln b/bunit.sln
index a62447920..d405041fc 100644
--- a/bunit.sln
+++ b/bunit.sln
@@ -19,6 +19,7 @@ EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{6EA09ED4-B714-4E6F-B0E1-4D987F8AE520}"
 	ProjectSection(SolutionItems) = preProject
 		tests\Directory.Build.props = tests\Directory.Build.props
+		tests\run-tests.ps1 = tests\run-tests.ps1
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".text", ".text", "{392FCD4E-356A-412A-A854-8EE197EA65B9}"
diff --git a/src/Directory.Build.props b/src/Directory.Build.props
index dc1a9ad8e..c56d53a84 100644
--- a/src/Directory.Build.props
+++ b/src/Directory.Build.props
@@ -23,9 +23,9 @@
 		<Deterministic>true</Deterministic>
 	</PropertyGroup>
 
-	<PropertyGroup Condition="'$(Configuration)' == 'Release' AND $(MSBuildProjectName)!='bunit.template' AND $(MSBuildProjectName)!='bunit'">
+	<!--<PropertyGroup Condition="'$(Configuration)' == 'Release' AND $(MSBuildProjectName)!='bunit.template' AND $(MSBuildProjectName)!='bunit'">
 		<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-	</PropertyGroup>
+	</PropertyGroup>-->
 
 	<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.1' AND $(MSBuildProjectName)!='bunit.template' AND $(MSBuildProjectName)!='bunit'">
 		<PackageReference Include="Microsoft.AspNetCore.Components.Authorization" Version="3.1.1" />
diff --git a/src/bunit.core/Extensions/RenderedComponentInvokeAsyncExtension.cs b/src/bunit.core/Extensions/RenderedComponentInvokeAsyncExtension.cs
index cf444aa99..0d1a69740 100644
--- a/src/bunit.core/Extensions/RenderedComponentInvokeAsyncExtension.cs
+++ b/src/bunit.core/Extensions/RenderedComponentInvokeAsyncExtension.cs
@@ -1,8 +1,11 @@
 using System;
 using System.Text;
 using System.Threading.Tasks;
+
 using Bunit.Rendering;
+
 using Microsoft.AspNetCore.Components;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Bunit
 {
@@ -23,7 +26,8 @@ public static Task InvokeAsync<TComponent>(this IRenderedComponentBase<TComponen
 			if (renderedComponent is null)
 				throw new ArgumentNullException(nameof(renderedComponent));
 
-			return renderedComponent.Renderer.Dispatcher.InvokeAsync(callback);
+			return renderedComponent.Services.GetRequiredService<ITestRenderer>()
+				.Dispatcher.InvokeAsync(callback);
 		}
 
 		/// <summary>
@@ -38,7 +42,8 @@ public static Task InvokeAsync<TComponent>(this IRenderedComponentBase<TComponen
 			if (renderedComponent is null)
 				throw new ArgumentNullException(nameof(renderedComponent));
 
-			return renderedComponent.Renderer.Dispatcher.InvokeAsync(callback);
+			return renderedComponent.Services.GetRequiredService<ITestRenderer>()
+				.Dispatcher.InvokeAsync(callback);
 		}
 	}
 }
diff --git a/src/bunit.core/IRenderedFragmentBase.cs b/src/bunit.core/IRenderedFragmentBase.cs
index 6029f4946..5bfd52820 100644
--- a/src/bunit.core/IRenderedFragmentBase.cs
+++ b/src/bunit.core/IRenderedFragmentBase.cs
@@ -1,28 +1,18 @@
 using System;
-using System.Threading.Tasks;
+
 using Bunit.Rendering;
 
 namespace Bunit
 {
-	/// <summary>
-	/// Represents a rendered fragment.
-	/// </summary>
-	public interface IRenderedFragmentBase
+	public interface IRenderedFragmentBase : IDisposable
 	{
-		/// <summary>
-		/// Gets the id of the rendered component or fragment.
-		/// </summary>
-		int ComponentId { get; }
-
-		/// <summary>
-		/// Gets the total number times the fragment has been through its render life-cycle.
-		/// </summary>
 		int RenderCount { get; }
 
-		/// <summary>
-		/// Adds or removes an event handler that will be triggered after each render of this <see cref="IRenderedFragmentBase"/>.
-		/// </summary>
-		event Action OnAfterRender;
+		bool IsDisposed { get; }
+
+		int ComponentId { get; }
+
+		void OnRender(RenderEvent renderEvent);
 
 		/// <summary>
 		/// Gets the <see cref="IServiceProvider"/> used when rendering the component.
@@ -30,8 +20,8 @@ public interface IRenderedFragmentBase
 		IServiceProvider Services { get; }
 
 		/// <summary>
-		/// Gets the <see cref="ITestRenderer"/> renderer that rendered the component.
+		/// Adds or removes an event handler that will be triggered after each render of this <see cref="IRenderedFragmentBase"/>.
 		/// </summary>
-		ITestRenderer Renderer { get; }
+		event Action? OnAfterRender;
 	}
 }
diff --git a/src/bunit.core/Rendering/ComponentDisposedException.cs b/src/bunit.core/Rendering/ComponentDisposedException.cs
index 56a8782b2..3aeeea3e5 100644
--- a/src/bunit.core/Rendering/ComponentDisposedException.cs
+++ b/src/bunit.core/Rendering/ComponentDisposedException.cs
@@ -5,7 +5,7 @@
 namespace Bunit.Rendering
 {
 	/// <summary>
-	/// Represents an exception that is thrown when a <see cref="IRenderedFragmentBase"/>'s
+	/// Represents an exception that is thrown when a <see cref="Bunit.IRenderedFragmentBase"/>'s
 	/// properties is accessed after the underlying component has been dispsoed by the renderer.
 	/// </summary>
 	public class ComponentDisposedException : Exception
diff --git a/src/bunit.core/Rendering/IRenderEventHandler.cs b/src/bunit.core/Rendering/IRenderEventHandler.cs
deleted file mode 100644
index 2ea606b8e..000000000
--- a/src/bunit.core/Rendering/IRenderEventHandler.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-using System.Threading.Tasks;
-
-namespace Bunit.Rendering
-{
-	/// <summary>
-	/// Represents a type that handle <see cref="RenderEvent"/>
-	/// from a <see cref="TestRenderer"/> or one of the components it
-	/// has rendered.
-	/// </summary>
-	public interface IRenderEventHandler
-	{
-		/// <summary>
-		/// A handler for <see cref="RenderEvent"/>s.
-		/// Must return a completed task when it is done processing the render event.
-		/// </summary>
-		/// <param name="renderEvent">The render event to process</param>
-		/// <returns>A <see cref="Task"/> that completes when the render event has been processed.</returns>
-		Task Handle(RenderEvent renderEvent);
-	}
-}
diff --git a/src/bunit.core/Rendering/IRenderEventProducer.cs b/src/bunit.core/Rendering/IRenderEventProducer.cs
deleted file mode 100644
index d24d6ba43..000000000
--- a/src/bunit.core/Rendering/IRenderEventProducer.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-namespace Bunit.Rendering
-{
-	/// <summary>
-	/// Represents a producer of <see cref="RenderEvent"/>s.
-	/// </summary>
-	public interface IRenderEventProducer
-	{
-		/// <summary>
-		/// Adds a <see cref="IRenderEventHandler"/> to this renderer,
-		/// which will be triggered when the renderer has finished rendering
-		/// a render cycle.
-		/// </summary>
-		/// <param name="handler">The handler to add.</param>
-		void AddRenderEventHandler(IRenderEventHandler handler);
-
-		/// <summary>
-		/// Removes a <see cref="IRenderEventHandler"/> from this renderer.
-		/// </summary>
-		/// <param name="handler">The handler to remove.</param>
-		void RemoveRenderEventHandler(IRenderEventHandler handler);
-	}
-}
diff --git a/src/bunit.core/Rendering/IRenderedComponentActivator.cs b/src/bunit.core/Rendering/IRenderedComponentActivator.cs
new file mode 100644
index 000000000..3042c93dc
--- /dev/null
+++ b/src/bunit.core/Rendering/IRenderedComponentActivator.cs
@@ -0,0 +1,16 @@
+
+using Microsoft.AspNetCore.Components;
+
+namespace Bunit.Rendering
+{
+	public interface IRenderedComponentActivator
+	{
+		IRenderedFragmentBase CreateRenderedComponent(int componentId);
+
+		IRenderedComponentBase<TComponent> CreateRenderedComponent<TComponent>(int componentId)
+			where TComponent : IComponent;
+
+		IRenderedComponentBase<TComponent> CreateRenderedComponent<TComponent>(int componentId, TComponent component, RenderTreeFrameCollection componentFrames)
+			where TComponent : IComponent;
+	}
+}
diff --git a/src/bunit.core/Rendering/ITestRenderer.cs b/src/bunit.core/Rendering/ITestRenderer.cs
index 9ea456f2d..e78ca2769 100644
--- a/src/bunit.core/Rendering/ITestRenderer.cs
+++ b/src/bunit.core/Rendering/ITestRenderer.cs
@@ -11,36 +11,13 @@ namespace Bunit.Rendering
 	/// <summary>
 	/// Represents a generalized Blazor renderer for testing purposes.
 	/// </summary>
-	public interface ITestRenderer : IRenderEventProducer
+	public interface ITestRenderer
 	{
 		/// <summary>
 		/// Gets the <see cref="Dispatcher"/> associated with this <see cref="ITestRenderer"/>.
 		/// </summary>
 		Dispatcher Dispatcher { get; }
 
-		///// <summary>
-		///// Invokes the given <paramref name="callback"/> in the context of this <see cref="ITestRenderer"/>.
-		///// </summary>
-		///// <param name="callback"></param>
-		///// <returns>A <see cref="Task"/> that will be completed when the action has finished executing.</returns>
-		//Task InvokeAsync(Action callback);
-
-		/// <summary>
-		/// Instantiates and renders the component of type <typeparamref name="TComponent"/>.
-		/// </summary>
-		/// <typeparam name="TComponent">Type of component to render.</typeparam>
-		/// <param name="parameters">Parameters to pass to the component during first render.</param>
-		/// <returns>The component and its assigned id.</returns>
-		(int ComponentId, TComponent Component) RenderComponent<TComponent>(IEnumerable<ComponentParameter> parameters) where TComponent : IComponent;
-
-		/// <summary>
-		/// Renders the provided <paramref name="renderFragment"/> inside a wrapper and returns
-		/// the wrappers component id.
-		/// </summary>
-		/// <param name="renderFragment"><see cref="Microsoft.AspNetCore.Components.RenderFragment"/> to render.</param>
-		/// <returns>The id of the wrapper component which the <paramref name="renderFragment"/> is rendered inside.</returns>
-		int RenderFragment(RenderFragment renderFragment);
-
 		/// <summary>
 		/// Notifies the renderer that an event has occurred.
 		/// </summary>
@@ -50,27 +27,15 @@ public interface ITestRenderer : IRenderEventProducer
 		/// <returns>A <see cref="Task"/> which will complete once all asynchronous processing related to the event has completed.</returns>
 		Task DispatchEventAsync(ulong eventHandlerId, EventFieldInfo fieldInfo, EventArgs eventArgs);
 
-		/// <summary>
-		/// Performs a depth-first search for a <typeparamref name="TComponent"/> child component of the component with the <paramref name="parentComponentId"/>.
-		/// </summary>
-		/// <typeparam name="TComponent">Type of component to look for.</typeparam>
-		/// <param name="parentComponentId">The id of the parent component.</param>
-		/// <returns>The first matching child component.</returns>
-		(int ComponentId, TComponent Component) FindComponent<TComponent>(int parentComponentId);
+		IRenderedFragmentBase RenderFragment(RenderFragment renderFragment);
 
-		/// <summary>
-		/// Performs a depth-first search for all <typeparamref name="TComponent"/> child components of the component with the <paramref name="parentComponentId"/>.
-		/// </summary>
-		/// <typeparam name="TComponent">Type of components to look for.</typeparam>
-		/// <param name="parentComponentId">The id of the parent component.</param>
-		/// <returns>The matching child components.</returns>
-		IReadOnlyList<(int ComponentId, TComponent Component)> FindComponents<TComponent>(int parentComponentId);
+		IRenderedComponentBase<TComponent> RenderComponent<TComponent>(IEnumerable<ComponentParameter> componentParameters)
+			where TComponent : IComponent;
 
-		/// <summary>
-		/// Gets the current render tree for a given component.
-		/// </summary>
-		/// <param name="componentId">The id for the component.</param>
-		/// <returns>The <see cref="RenderTreeBuilder"/> representing the current render tree.</returns>
-		ArrayRange<RenderTreeFrame> GetCurrentRenderTreeFrames(int componentId);
+		IRenderedComponentBase<TComponent> FindComponent<TComponent>(IRenderedFragmentBase parentComponent)
+			where TComponent : IComponent;
+
+		IReadOnlyList<IRenderedComponentBase<TComponent>> FindComponents<TComponent>(IRenderedFragmentBase parentComponent)
+			where TComponent : IComponent;
 	}
 }
diff --git a/src/bunit.core/Rendering/NewRenderEvent.cs b/src/bunit.core/Rendering/NewRenderEvent.cs
deleted file mode 100644
index 509dafb10..000000000
--- a/src/bunit.core/Rendering/NewRenderEvent.cs
+++ /dev/null
@@ -1,108 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-using Microsoft.AspNetCore.Components.RenderTree;
-
-namespace Bunit.Rendering
-{
-	public sealed class RenderTreeFrameCollection
-	{
-		private Dictionary<int, ArrayRange<RenderTreeFrame>> _currentRenderTree = new Dictionary<int, ArrayRange<RenderTreeFrame>>();
-
-		public ArrayRange<RenderTreeFrame> this[int componentId] => _currentRenderTree[componentId];
-
-		internal RenderTreeFrameCollection() { }
-
-		public bool Contains(int componentId) => _currentRenderTree.ContainsKey(componentId);
-
-		internal void Add(int componentId, ArrayRange<RenderTreeFrame> frames) => _currentRenderTree.Add(componentId, frames);
-	}
-
-	public sealed class NewRenderEvent
-	{
-		private readonly RenderBatch _renderBatch;
-
-		public RenderTreeFrameCollection Frames { get; }
-
-		internal NewRenderEvent(RenderBatch renderBatch, RenderTreeFrameCollection frames)
-		{
-			_renderBatch = renderBatch;
-			Frames = frames;
-		}
-
-		public (bool rendered, bool changed, bool disposed) GetRenderStatus(IRenderedComponent renderedComponent)
-		{
-			if (renderedComponent is null)
-				throw new ArgumentNullException(nameof(renderedComponent));
-
-			var result = (rendered: false, changed: false, disposed: false);
-
-			if (DidComponentDispose(renderedComponent))
-			{
-				result.disposed = true;
-			}
-			else
-			{
-				(result.rendered, result.changed) = GetRenderAndChangeStatus(renderedComponent);
-			}
-
-			return result;
-		}
-
-		private bool DidComponentDispose(IRenderedComponent renderedComponent)
-		{
-			for (var i = 0; i < _renderBatch.DisposedComponentIDs.Count; i++)
-				if (_renderBatch.DisposedComponentIDs.Array[i].Equals(renderedComponent.ComponentId))
-					return true;
-
-			return false;
-		}
-
-		private (bool rendered, bool hasChanges) GetRenderAndChangeStatus(IRenderedComponent renderedComponent)
-		{
-			var result = (rendered: false, hasChanges: false);
-
-			GetStatus(renderedComponent.ComponentId);
-
-			return result;
-
-			void GetStatus(int componentId)
-			{
-				for (var i = 0; i < _renderBatch.UpdatedComponents.Count; i++)
-				{
-					ref var update = ref _renderBatch.UpdatedComponents.Array[i];
-					if (update.ComponentId == componentId)
-					{
-						result.rendered = true;
-						result.hasChanges = update.Edits.Count > 0;
-						break;
-					}
-				}
-
-				if (!result.hasChanges)
-				{
-					GetStatusFromChildren(componentId);
-				}
-			}
-
-			void GetStatusFromChildren(int componentId)
-			{
-				var frames = Frames[componentId];
-				for (var i = 0; i < frames.Count; i++)
-				{
-					ref var frame = ref frames.Array[i];
-					if (frame.FrameType == RenderTreeFrameType.Component)
-					{
-						GetStatus(frame.ComponentId);
-
-						if (result.hasChanges)
-						{
-							break;
-						}
-					}
-				}
-			}
-		}
-	}
-}
diff --git a/src/bunit.core/Rendering/NewTestRenderer.cs b/src/bunit.core/Rendering/NewTestRenderer.cs
deleted file mode 100644
index cd8a4be05..000000000
--- a/src/bunit.core/Rendering/NewTestRenderer.cs
+++ /dev/null
@@ -1,275 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Runtime.ExceptionServices;
-using System.Text;
-using System.Threading.Tasks;
-
-using Microsoft.AspNetCore.Components;
-using Microsoft.AspNetCore.Components.RenderTree;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-
-namespace Bunit.Rendering
-{
-	public interface IRenderedComponent : IDisposable
-	{
-		bool IsDisposed { get; }
-
-		int ComponentId { get; }
-
-		void OnRender(NewRenderEvent renderEvent);
-	}
-
-	public interface IRenderedComponentActivator
-	{
-		IRenderedComponent CreateRenderedComponent(int componentId);
-		IRenderedComponent CreateRenderedComponent<T>(int componentId) where T : IComponent;
-		IRenderedComponent CreateRenderedComponent<T>(int componentId, T component, RenderTreeFrameCollection componentFrames) where T : IComponent;
-	}
-
-	public sealed class NewTestRenderer : Renderer
-	{
-		private readonly object _renderTreeAccessLock = new object();
-		private readonly ILogger _logger;
-		private readonly IRenderedComponentActivator _activator;
-		private Exception? _unhandledException;
-		private readonly Dictionary<int, IRenderedComponent> _renderedComponents = new Dictionary<int, IRenderedComponent>();
-
-		public override Dispatcher Dispatcher { get; } = Dispatcher.CreateDefault();
-
-		public NewTestRenderer(IRenderedComponentActivator activator, IServiceProvider services, ILoggerFactory loggerFactory) : base(services, loggerFactory)
-		{
-			_logger = loggerFactory.CreateLogger<TestRenderer>();
-			_activator = activator;
-		}
-
-		public IRenderedComponent RenderFragment(RenderFragment renderFragment)
-		{
-			IRenderedComponent renderedComponent = default!;
-			var task = Dispatcher.InvokeAsync(() =>
-			{
-				var root = new WrapperComponent(renderFragment);
-				var rootComponentId = AssignRootComponentId(root);
-				renderedComponent = _activator.CreateRenderedComponent(rootComponentId);
-				_renderedComponents.Add(rootComponentId, renderedComponent);
-				root.Render();
-			});
-
-			Debug.Assert(task.IsCompleted, "The render task did not complete as expected");
-			AssertNoUnhandledExceptions();
-
-			return renderedComponent!;
-		}
-
-		public IRenderedComponent RenderComponent<TComponent>(IEnumerable<ComponentParameter> componentParameters)
-			where TComponent : IComponent
-		{
-			IRenderedComponent renderedComponent = default!;
-			var task = Dispatcher.InvokeAsync(() =>
-			{
-				var root = new WrapperComponent(componentParameters.ToComponentRenderFragment<TComponent>());
-				var rootComponentId = AssignRootComponentId(root);
-				renderedComponent = _activator.CreateRenderedComponent<TComponent>(rootComponentId);
-				_renderedComponents.Add(rootComponentId, renderedComponent);
-				root.Render();
-			});
-
-			Debug.Assert(task.IsCompleted, "The render task did not complete as expected");
-			AssertNoUnhandledExceptions();
-
-			return renderedComponent!;
-		}
-
-
-		public IRenderedComponent FindComponent<TComponent>(IRenderedComponent parentComponent)
-			where TComponent : IComponent
-		{
-			if (parentComponent is null)
-				throw new ArgumentNullException(nameof(parentComponent));
-
-			var framesCollection = new RenderTreeFrameCollection();
-
-			lock (_renderTreeAccessLock)
-			{
-				if (TryFindComponent(parentComponent.ComponentId, out var id, out var component))
-				{
-					LoadRenderTreeFrames(id, framesCollection);
-					var rc = _activator.CreateRenderedComponent(id, component, framesCollection);
-					_renderedComponents.Add(rc.ComponentId, rc);
-					return rc;
-				}
-				else
-				{
-					throw new ComponentNotFoundException(typeof(TComponent));
-				}
-			}
-
-			bool TryFindComponent(int parentComponentId, out int componentId, out TComponent component)
-			{
-				var result = false;
-				componentId = -1;
-				component = default!;
-
-				var frames = LoadAndGetRenderTreeFrame(framesCollection, parentComponentId);
-
-				for (var i = 0; i < frames.Count; i++)
-				{
-					ref var frame = ref frames.Array[i];
-					if (frame.FrameType == RenderTreeFrameType.Component)
-					{
-						if (frame.Component is TComponent c)
-						{
-							componentId = frame.ComponentId;
-							component = c;
-							result = true;
-							break;
-						}
-
-						if (TryFindComponent(frame.ComponentId, out componentId, out component))
-						{
-							result = true;
-							break;
-						}
-					}
-				}
-
-				return result;
-			}
-		}
-
-		public IReadOnlyList<IRenderedComponent> FindComponents<TComponent>(IRenderedComponent parentComponent)
-			where TComponent : IComponent
-		{
-			if (parentComponent is null)
-				throw new ArgumentNullException(nameof(parentComponent));
-
-			var result = new List<IRenderedComponent>();
-			var framesCollection = new RenderTreeFrameCollection();
-
-			lock (_renderTreeAccessLock)
-			{
-				FindComponentsInternal(parentComponent.ComponentId);
-				foreach (var rc in result)
-				{
-					_renderedComponents.Add(rc.ComponentId, rc);
-				}
-			}
-
-			return result;
-
-			void FindComponentsInternal(int componentId)
-			{
-				var frames = LoadAndGetRenderTreeFrame(framesCollection, componentId);
-
-				for (var i = 0; i < frames.Count; i++)
-				{
-					ref var frame = ref frames.Array[i];
-					if (frame.FrameType == RenderTreeFrameType.Component)
-					{
-						if (frame.Component is TComponent component)
-						{
-							var id = frame.ComponentId;
-							LoadRenderTreeFrames(id, framesCollection);
-							var rc = _activator.CreateRenderedComponent(id, component, framesCollection);
-							result.Add(rc);
-						}
-
-						FindComponentsInternal(frame.ComponentId);
-					}
-				}
-			}
-		}
-
-		/// <inheritdoc/>
-		protected override void ProcessPendingRender()
-		{
-			lock (_renderTreeAccessLock)
-			{
-				base.ProcessPendingRender();
-			}
-		}
-
-		/// <inheritdoc/>
-		protected override void HandleException(Exception exception)
-			=> _unhandledException = exception;
-
-		/// <inheritdoc/>
-		protected override Task UpdateDisplayAsync(in RenderBatch renderBatch)
-		{
-			var renderEvent = new NewRenderEvent(renderBatch, new RenderTreeFrameCollection());
-
-			// removes disposed components
-			for (var i = 0; i < renderBatch.DisposedComponentIDs.Count; i++)
-			{
-				var id = renderBatch.DisposedComponentIDs.Array[i];
-				if (_renderedComponents.TryGetValue(id, out var rc))
-				{
-					_renderedComponents.Remove(id);
-					rc.OnRender(renderEvent);
-				}
-			}
-
-			foreach (var (key, rc) in _renderedComponents.ToArray())
-			{
-				LoadRenderTreeFrames(rc.ComponentId, renderEvent.Frames);
-				rc.OnRender(renderEvent);
-
-				// RC can replace the instance of the component is bound
-				// to while processing the update event. 
-				if (key != rc.ComponentId)
-				{
-					_renderedComponents.Remove(key);
-					_renderedComponents.Add(rc.ComponentId, rc);
-				}
-			}
-
-			return Task.CompletedTask;
-		}
-
-		protected override void Dispose(bool disposing)
-		{
-			foreach (var rc in _renderedComponents.Values)
-			{
-				rc.Dispose();
-			}
-			base.Dispose(disposing);
-		}
-
-		private void LoadRenderTreeFrames(int componentId, RenderTreeFrameCollection framesCollection)
-		{
-			var frames = LoadAndGetRenderTreeFrame(framesCollection, componentId);
-
-			for (var i = 0; i < frames.Count; i++)
-			{
-				ref var frame = ref frames.Array[i];
-				if (frame.FrameType == RenderTreeFrameType.Component)
-				{
-					LoadRenderTreeFrames(frame.ComponentId, framesCollection);
-				}
-			}
-		}
-
-		private ArrayRange<RenderTreeFrame> LoadAndGetRenderTreeFrame(RenderTreeFrameCollection framesCollection, int componentId)
-		{
-			if (!framesCollection.Contains(componentId))
-			{
-				framesCollection.Add(componentId, GetCurrentRenderTreeFrames(componentId));
-			}
-
-			return framesCollection[componentId];
-		}
-
-		private void AssertNoUnhandledExceptions()
-		{
-			if (_unhandledException is { } unhandled)
-			{
-				_unhandledException = null;
-				var evt = new EventId(3, nameof(AssertNoUnhandledExceptions));
-				_logger.LogError(evt, unhandled, $"An unhandled exception happened during rendering: {unhandled.Message}{Environment.NewLine}{unhandled.StackTrace}");
-				ExceptionDispatchInfo.Capture(unhandled).Throw();
-			}
-		}
-	}
-}
diff --git a/src/bunit.core/Rendering/RenderEvent.cs b/src/bunit.core/Rendering/RenderEvent.cs
index 22c3d3f67..a743a5e9d 100644
--- a/src/bunit.core/Rendering/RenderEvent.cs
+++ b/src/bunit.core/Rendering/RenderEvent.cs
@@ -1,115 +1,94 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
+
 using Microsoft.AspNetCore.Components.RenderTree;
 
 namespace Bunit.Rendering
 {
-	/// <summary>
-	/// Represents a render event from a <see cref="ITestRenderer"/>.
-	/// </summary>
 	public sealed class RenderEvent
 	{
-		private readonly ITestRenderer _renderer;
 		private readonly RenderBatch _renderBatch;
 
-		/// <summary>
-		/// Gets the related <see cref="RenderBatch"/> from the render.
-		/// </summary>
-		public ref readonly RenderBatch RenderBatch => ref _renderBatch;
+		public RenderTreeFrameCollection Frames { get; }
 
-		/// <summary>
-		/// Creates an instance of the <see cref="RenderEvent"/> type.
-		/// </summary>
-		public RenderEvent(in RenderBatch renderBatch, ITestRenderer renderer)
+		internal RenderEvent(RenderBatch renderBatch, RenderTreeFrameCollection frames)
 		{
 			_renderBatch = renderBatch;
-			_renderer = renderer;
+			Frames = frames;
 		}
 
-		/// <summary>
-		/// Checks whether the a component with <paramref name="componentId"/> or one or more of 
-		/// its sub components was changed during the <see cref="RenderEvent"/>.
-		/// </summary>
-		/// <param name="componentId">Id of component to check for updates to.</param>
-		/// <returns>True if <see cref="RenderEvent"/> contains updates to component, false otherwise.</returns>
-		public bool HasMarkupChanges(int componentId)
+		public (bool rendered, bool changed, bool disposed) GetRenderStatus(IRenderedFragmentBase renderedComponent)
 		{
-			return HasChangesToRoot(componentId);
+			if (renderedComponent is null)
+				throw new ArgumentNullException(nameof(renderedComponent));
 
-			bool HasChangesToRoot(int componentId)
-			{
-				for (var i = 0; i < _renderBatch.UpdatedComponents.Count; i++)
-				{
-					ref var update = ref _renderBatch.UpdatedComponents.Array[i];
-					if (update.ComponentId == componentId && update.Edits.Count > 0)
-						return true;
-				}
+			var result = (rendered: false, changed: false, disposed: false);
 
-				var renderFrames = _renderer.GetCurrentRenderTreeFrames(componentId);
-				return HasChangedToChildren(renderFrames);
+			if (DidComponentDispose(renderedComponent))
+			{
+				result.disposed = true;
 			}
-
-			bool HasChangedToChildren(ArrayRange<RenderTreeFrame> componentRenderTreeFrames)
+			else
 			{
-				for (var i = 0; i < componentRenderTreeFrames.Count; i++)
-				{
-					ref var frame = ref componentRenderTreeFrames.Array[i];
-					if (frame.FrameType == RenderTreeFrameType.Component)
-						if (HasChangesToRoot(frame.ComponentId))
-							return true;
-				}
-				return false;
+				(result.rendered, result.changed) = GetRenderAndChangeStatus(renderedComponent);
 			}
+
+			return result;
 		}
 
-		/// <summary>
-		/// Checks whether the a component with <paramref name="componentId"/> was disposed.
-		/// </summary>
-		/// <param name="componentId">Id of component to check.</param>
-		/// <returns>True if component was disposed, false otherwise.</returns>
-		public bool DidComponentDispose(int componentId)
+		private bool DidComponentDispose(IRenderedFragmentBase renderedComponent)
 		{
 			for (var i = 0; i < _renderBatch.DisposedComponentIDs.Count; i++)
-				if (_renderBatch.DisposedComponentIDs.Array[i].Equals(componentId))
+				if (_renderBatch.DisposedComponentIDs.Array[i].Equals(renderedComponent.ComponentId))
 					return true;
 
 			return false;
 		}
 
-		/// <summary>
-		/// Checks whether the a component with <paramref name="componentId"/> or one or more of 
-		/// its sub components was rendered during the <see cref="RenderEvent"/>.
-		/// </summary>
-		/// <param name="componentId">Id of component to check if rendered.</param>
-		/// <returns>True if the component or a sub component rendered, false otherwise.</returns>
-		public bool DidComponentRender(int componentId)
+		private (bool rendered, bool hasChanges) GetRenderAndChangeStatus(IRenderedFragmentBase renderedComponent)
 		{
-			return DidComponentRenderRoot(componentId);
+			var result = (rendered: false, hasChanges: false);
+
+			GetStatus(renderedComponent.ComponentId);
 
-			bool DidComponentRenderRoot(int componentId)
+			return result;
+
+			void GetStatus(int componentId)
 			{
 				for (var i = 0; i < _renderBatch.UpdatedComponents.Count; i++)
 				{
 					ref var update = ref _renderBatch.UpdatedComponents.Array[i];
 					if (update.ComponentId == componentId)
-						return true;
+					{
+						result.rendered = true;
+						result.hasChanges = update.Edits.Count > 0;
+						break;
+					}
 				}
 
-				return DidChildComponentRender(componentId);
+				if (!result.hasChanges)
+				{
+					GetStatusFromChildren(componentId);
+				}
 			}
 
-			bool DidChildComponentRender(int componentId)
+			void GetStatusFromChildren(int componentId)
 			{
-				var frames = _renderer.GetCurrentRenderTreeFrames(componentId);
-
+				var frames = Frames[componentId];
 				for (var i = 0; i < frames.Count; i++)
 				{
 					ref var frame = ref frames.Array[i];
 					if (frame.FrameType == RenderTreeFrameType.Component)
-						if (DidComponentRenderRoot(frame.ComponentId))
-							return true;
-				}
+					{
+						GetStatus(frame.ComponentId);
 
-				return false;
+						if (result.hasChanges)
+						{
+							break;
+						}
+					}
+				}
 			}
 		}
 	}
diff --git a/src/bunit.core/Rendering/RenderTreeFrameCollection.cs b/src/bunit.core/Rendering/RenderTreeFrameCollection.cs
new file mode 100644
index 000000000..049408f08
--- /dev/null
+++ b/src/bunit.core/Rendering/RenderTreeFrameCollection.cs
@@ -0,0 +1,51 @@
+using System.Collections.Generic;
+
+using Microsoft.AspNetCore.Components.RenderTree;
+
+namespace Bunit.Rendering
+{
+	public sealed class RenderTreeFrameCollection
+	{
+		private Dictionary<int, ArrayRange<RenderTreeFrame>> _currentRenderTree = new Dictionary<int, ArrayRange<RenderTreeFrame>>();
+
+		public ArrayRange<RenderTreeFrame> this[int componentId] => _currentRenderTree[componentId];
+
+		internal RenderTreeFrameCollection() { }
+
+		public bool Contains(int componentId) => _currentRenderTree.ContainsKey(componentId);
+
+		internal void Add(int componentId, ArrayRange<RenderTreeFrame> frames) => _currentRenderTree.Add(componentId, frames);
+
+		public bool TryFindComponent<TComponent>(int parentComponentId, out int componentId, out TComponent component)
+		{
+			var result = false;
+			componentId = -1;
+			component = default!;
+
+			var frames = _currentRenderTree[parentComponentId];
+
+			for (var i = 0; i < frames.Count; i++)
+			{
+				ref var frame = ref frames.Array[i];
+				if (frame.FrameType == RenderTreeFrameType.Component)
+				{
+					if (frame.Component is TComponent c)
+					{
+						componentId = frame.ComponentId;
+						component = c;
+						result = true;
+						break;
+					}
+
+					if (TryFindComponent(frame.ComponentId, out componentId, out component))
+					{
+						result = true;
+						break;
+					}
+				}
+			}
+
+			return result;
+		}
+	}
+}
diff --git a/src/bunit.core/Rendering/TestRenderer.cs b/src/bunit.core/Rendering/TestRenderer.cs
index 474e927b2..a1399e422 100644
--- a/src/bunit.core/Rendering/TestRenderer.cs
+++ b/src/bunit.core/Rendering/TestRenderer.cs
@@ -1,222 +1,273 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Runtime.ExceptionServices;
+using System.Text;
 using System.Threading.Tasks;
 
-using Bunit.Extensions;
-
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.RenderTree;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 namespace Bunit.Rendering
 {
-	/// <summary>
-	/// Generalized Blazor renderer for testing purposes.
-	/// </summary>
-	public class TestRenderer : Renderer, ITestRenderer, IRenderEventProducer
+	public sealed class TestRenderer : Renderer, ITestRenderer
 	{
+		private readonly object _renderTreeAccessLock = new object();
 		private readonly ILogger _logger;
-		private readonly List<IRenderEventHandler> _renderEventHandlers = new List<IRenderEventHandler>();
+		private readonly IRenderedComponentActivator _activator;
 		private Exception? _unhandledException;
+		private readonly Dictionary<int, IRenderedFragmentBase> _renderedComponents = new Dictionary<int, IRenderedFragmentBase>();
 
-		/// <inheritdoc/>
 		public override Dispatcher Dispatcher { get; } = Dispatcher.CreateDefault();
 
-		/// <summary>
-		/// Creates an instance of the <see cref="TestRenderer"/> class.
-		/// </summary>
-		public TestRenderer(IServiceProvider services, ILoggerFactory loggerFactory) : base(services, loggerFactory)
+		public TestRenderer(IRenderedComponentActivator activator, IServiceProvider services, ILoggerFactory loggerFactory) : base(services, loggerFactory)
 		{
 			_logger = loggerFactory.CreateLogger<TestRenderer>();
+			_activator = activator;
 		}
 
-		/// <summary>
-		/// Adds a <see cref="IRenderEventHandler"/> to this renderer,
-		/// which will be triggered when the renderer has finished rendering
-		/// a render cycle.
-		/// </summary>
-		/// <param name="handler">The handler to add.</param>
-		public void AddRenderEventHandler(IRenderEventHandler handler) => _renderEventHandlers.Add(handler);
-
-		/// <summary>
-		/// Removes a <see cref="IRenderEventHandler"/> from this renderer.
-		/// </summary>
-		/// <param name="handler">The handler to remove.</param>
-		public void RemoveRenderEventHandler(IRenderEventHandler handler) => _renderEventHandlers.Remove(handler);
-
-		/// <inheritdoc/>
-		public (int ComponentId, TComponent Component) RenderComponent<TComponent>(IEnumerable<ComponentParameter> parameters) where TComponent : IComponent
+		public IRenderedFragmentBase RenderFragment(RenderFragment renderFragment)
 		{
-			var componentType = typeof(TComponent);
-			var renderFragment = parameters.ToComponentRenderFragment<TComponent>();
-			var wrapperId = RenderFragmentInsideWrapper(renderFragment);
-			return FindComponent<TComponent>(wrapperId);
-		}
+			IRenderedFragmentBase renderedComponent = default!;
+			var task = Dispatcher.InvokeAsync(() =>
+			{
+				var root = new WrapperComponent(renderFragment);
+				var rootComponentId = AssignRootComponentId(root);
+				renderedComponent = _activator.CreateRenderedComponent(rootComponentId);
+				_renderedComponents.Add(rootComponentId, renderedComponent);
+				root.Render();
+			});
+
+			Debug.Assert(task.IsCompleted, "The render task did not complete as expected");
+			AssertNoUnhandledExceptions();
 
-		/// <inheritdoc/>
-		public int RenderFragment(RenderFragment renderFragment)
-		{
-			return RenderFragmentInsideWrapper(renderFragment);
+			return renderedComponent!;
 		}
 
-		/// <inheritdoc/>
-		public (int ComponentId, TComponent Component) FindComponent<TComponent>(int parentComponentId)
+		public IRenderedComponentBase<TComponent> RenderComponent<TComponent>(IEnumerable<ComponentParameter> componentParameters)
+			where TComponent : IComponent
 		{
-			var result = GetComponent<TComponent>(parentComponentId);
-			if (result.HasValue)
-				return result.Value;
-			else
-				throw new ComponentNotFoundException(typeof(TComponent));
-		}
+			IRenderedComponentBase<TComponent> renderedComponent = default!;
+			var task = Dispatcher.InvokeAsync(() =>
+			{
+				var root = new WrapperComponent(componentParameters.ToComponentRenderFragment<TComponent>());
+				var rootComponentId = AssignRootComponentId(root);
+				renderedComponent = _activator.CreateRenderedComponent<TComponent>(rootComponentId);
+				_renderedComponents.Add(rootComponentId, renderedComponent);
+				root.Render();
+			});
+
+			Debug.Assert(task.IsCompleted, "The render task did not complete as expected");
+			AssertNoUnhandledExceptions();
 
-		/// <inheritdoc/>
-		public IReadOnlyList<(int ComponentId, TComponent Component)> FindComponents<TComponent>(int parentComponentId)
-		{
-			return GetComponents<TComponent>(parentComponentId);
+			return renderedComponent!;
 		}
 
-		/// <inheritdoc/>
-		public new ArrayRange<RenderTreeFrame> GetCurrentRenderTreeFrames(int componentId)
+		public IRenderedComponentBase<TComponent> FindComponent<TComponent>(IRenderedFragmentBase parentComponent) where TComponent : IComponent
 		{
-			return base.GetCurrentRenderTreeFrames(componentId);
-		}
+			if (parentComponent is null)
+				throw new ArgumentNullException(nameof(parentComponent));
 
-		/// <inheritdoc/>
-		public new Task DispatchEventAsync(ulong eventHandlerId, EventFieldInfo fieldInfo, EventArgs eventArgs)
-		{
-			if (fieldInfo is null)
-				throw new ArgumentNullException(nameof(fieldInfo));
+			var framesCollection = new RenderTreeFrameCollection();
 
-			_logger.LogDebug(new EventId(10, nameof(DispatchEventAsync)), $"Starting trigger of '{fieldInfo.FieldValue}'");
+			lock (_renderTreeAccessLock)
+			{
+				if (TryFindComponent(parentComponent.ComponentId, out var id, out var component))
+				{
+					LoadRenderTreeFrames(id, framesCollection);
+					var rc = _activator.CreateRenderedComponent(id, component, framesCollection);
+					_renderedComponents.Add(rc.ComponentId, rc);
+					return rc;
+				}
+				else
+				{
+					throw new ComponentNotFoundException(typeof(TComponent));
+				}
+			}
 
-			var result = Dispatcher.InvokeAsync(() => base.DispatchEventAsync(eventHandlerId, fieldInfo, eventArgs));
+			bool TryFindComponent(int parentComponentId, out int componentId, out TComponent component)
+			{
+				var result = false;
+				componentId = -1;
+				component = default!;
 
-			AssertNoUnhandledExceptions();
+				var frames = LoadAndGetRenderTreeFrame(framesCollection, parentComponentId);
+
+				for (var i = 0; i < frames.Count; i++)
+				{
+					ref var frame = ref frames.Array[i];
+					if (frame.FrameType == RenderTreeFrameType.Component)
+					{
+						if (frame.Component is TComponent c)
+						{
+							componentId = frame.ComponentId;
+							component = c;
+							result = true;
+							break;
+						}
+
+						if (TryFindComponent(frame.ComponentId, out componentId, out component))
+						{
+							result = true;
+							break;
+						}
+					}
+				}
 
-			if (result.IsCompletedSuccessfully)
+				return result;
+			}
+		}
+
+		public IReadOnlyList<IRenderedComponentBase<TComponent>> FindComponents<TComponent>(IRenderedFragmentBase parentComponent)
+			where TComponent : IComponent
+		{
+			if (parentComponent is null)
+				throw new ArgumentNullException(nameof(parentComponent));
+
+			var result = new List<IRenderedComponentBase<TComponent>>();
+			var framesCollection = new RenderTreeFrameCollection();
+
+			lock (_renderTreeAccessLock)
 			{
-				_logger.LogDebug(new EventId(11, nameof(DispatchEventAsync)), $"Finished trigger synchronously for '{fieldInfo.FieldValue}'");
+				FindComponentsInternal(parentComponent.ComponentId);
+				foreach (var rc in result)
+				{
+					_renderedComponents.Add(rc.ComponentId, rc);
+				}
 			}
-			else
+
+			return result;
+
+			void FindComponentsInternal(int componentId)
 			{
-				_logger.LogDebug(new EventId(13, nameof(DispatchEventAsync)), $"Event handler for '{fieldInfo.FieldValue}' returned an incomplete task with status {result.Status}");
-				result = result.ContinueWith(x =>
+				var frames = LoadAndGetRenderTreeFrame(framesCollection, componentId);
+
+				for (var i = 0; i < frames.Count; i++)
 				{
-					if (x.IsCompletedSuccessfully)
+					ref var frame = ref frames.Array[i];
+					if (frame.FrameType == RenderTreeFrameType.Component)
 					{
-						_logger.LogDebug(new EventId(12, nameof(DispatchEventAsync)), $"Finished trigger asynchronously for '{fieldInfo.FieldValue}'");
+						if (frame.Component is TComponent component)
+						{
+							var id = frame.ComponentId;
+							LoadRenderTreeFrames(id, framesCollection);
+							var rc = _activator.CreateRenderedComponent(id, component, framesCollection);
+							result.Add(rc);
+						}
+
+						FindComponentsInternal(frame.ComponentId);
 					}
-				}, TaskScheduler.Default);
+				}
 			}
-
-			return result;
 		}
 
-		private int RenderFragmentInsideWrapper(RenderFragment renderFragment)
+		public new Task DispatchEventAsync(ulong eventHandlerId, EventFieldInfo fieldInfo, EventArgs eventArgs)
 		{
-			var wrapper = new WrapperComponent(renderFragment);
+			if (fieldInfo is null)
+				throw new ArgumentNullException(nameof(fieldInfo));
 
-			var wrapperId = AssignRootComponentId(wrapper);
-			AssertNoUnhandledExceptions();
+			var result = Dispatcher.InvokeAsync(() => base.DispatchEventAsync(eventHandlerId, fieldInfo, eventArgs));
 
-			Dispatcher.InvokeAsync(wrapper.Render).Wait();
 			AssertNoUnhandledExceptions();
 
-			return wrapperId;
+			return result;
+		}
+
+		/// <inheritdoc/>
+		protected override void ProcessPendingRender()
+		{
+			lock (_renderTreeAccessLock)
+			{
+				base.ProcessPendingRender();
+			}
 		}
 
 		/// <inheritdoc/>
-		protected override void HandleException(Exception exception) => _unhandledException = exception;
+		protected override void HandleException(Exception exception)
+			=> _unhandledException = exception;
 
 		/// <inheritdoc/>
 		protected override Task UpdateDisplayAsync(in RenderBatch renderBatch)
 		{
-			_logger.LogDebug(new EventId(0, nameof(UpdateDisplayAsync)), $"New render batch with ReferenceFrames = {renderBatch.ReferenceFrames.Count}, UpdatedComponents = {renderBatch.UpdatedComponents.Count}, DisposedComponentIDs = {renderBatch.DisposedComponentIDs.Count}, DisposedEventHandlerIDs = {renderBatch.DisposedEventHandlerIDs.Count}");
-
-			return _renderEventHandlers.Count == 0
-				? Task.CompletedTask
-				: PublishRenderEvent(in renderBatch);
-		}
+			var renderEvent = new RenderEvent(renderBatch, new RenderTreeFrameCollection());
 
-		private Task PublishRenderEvent(in RenderBatch renderBatch)
-		{
-			var renderEvent = new RenderEvent(in renderBatch, this);
+			// removes disposed components
+			for (var i = 0; i < renderBatch.DisposedComponentIDs.Count; i++)
+			{
+				var id = renderBatch.DisposedComponentIDs.Array[i];
+				if (_renderedComponents.TryGetValue(id, out var rc))
+				{
+					_renderedComponents.Remove(id);
+					rc.OnRender(renderEvent);
+				}
+			}
 
-			return _renderEventHandlers.Count switch
+			foreach (var (key, rc) in _renderedComponents.ToArray())
 			{
-				0 => Task.CompletedTask,
-				1 => _renderEventHandlers[0].Handle(renderEvent),
-				_ => NotifyEventHandlers(renderEvent)
-			};
-		}
+				LoadRenderTreeFrames(rc.ComponentId, renderEvent.Frames);
+				rc.OnRender(renderEvent);
 
-		private Task NotifyEventHandlers(RenderEvent renderEvent)
-		{
-			// copy to new array since _renderEventHandlers might be modified by the
-			// Handle method on event handlers if component is disposed.
-			var handleTasks = _renderEventHandlers
-				.ToArray()
-				.Select(x => x.Handle(renderEvent));
+				// RC can replace the instance of the component is bound
+				// to while processing the update event. 
+				if (key != rc.ComponentId)
+				{
+					_renderedComponents.Remove(key);
+					_renderedComponents.Add(rc.ComponentId, rc);
+				}
+			}
 
-			return Task.WhenAll(handleTasks);
+			return Task.CompletedTask;
 		}
 
-		private void AssertNoUnhandledExceptions()
+		/// <inheritdoc/>
+		protected override void Dispose(bool disposing)
 		{
-			if (_unhandledException is { } unhandled)
+			if (disposing)
 			{
-				_unhandledException = null;
-				var evt = new EventId(3, nameof(AssertNoUnhandledExceptions));
-				_logger.LogError(evt, unhandled, $"An unhandled exception happened during rendering: {unhandled.Message}{Environment.NewLine}{unhandled.StackTrace}");
-				ExceptionDispatchInfo.Capture(unhandled).Throw();
+				foreach (var rc in _renderedComponents.Values)
+				{
+					rc.Dispose();
+				}
+				_renderedComponents.Clear();
 			}
+			base.Dispose(disposing);
 		}
 
-		private (int ComponentId, TComponent Component)? GetComponent<TComponent>(int rootComponentId)
+		private void LoadRenderTreeFrames(int componentId, RenderTreeFrameCollection framesCollection)
 		{
-			var ownFrames = GetCurrentRenderTreeFrames(rootComponentId);
+			var frames = LoadAndGetRenderTreeFrame(framesCollection, componentId);
 
-			for (var i = 0; i < ownFrames.Count; i++)
+			for (var i = 0; i < frames.Count; i++)
 			{
-				ref var frame = ref ownFrames.Array[i];
+				ref var frame = ref frames.Array[i];
 				if (frame.FrameType == RenderTreeFrameType.Component)
 				{
-					if (frame.Component is TComponent component)
-						return (frame.ComponentId, component);
-
-					var result = GetComponent<TComponent>(frame.ComponentId);
-					if (result is { })
-						return result;
+					LoadRenderTreeFrames(frame.ComponentId, framesCollection);
 				}
 			}
-
-			return null;
 		}
 
-		private IReadOnlyList<(int ComponentId, TComponent Component)> GetComponents<TComponent>(int rootComponentId)
+		private ArrayRange<RenderTreeFrame> LoadAndGetRenderTreeFrame(RenderTreeFrameCollection framesCollection, int componentId)
 		{
-			var result = new List<(int ComponentId, TComponent Component)>();
-
-			GetComponentsInternal(rootComponentId, result);
+			if (!framesCollection.Contains(componentId))
+			{
+				framesCollection.Add(componentId, GetCurrentRenderTreeFrames(componentId));
+			}
 
-			return result;
+			return framesCollection[componentId];
+		}
 
-			void GetComponentsInternal(int rootComponentId, List<(int ComponentId, TComponent Component)> result)
+		private void AssertNoUnhandledExceptions()
+		{
+			if (_unhandledException is { } unhandled)
 			{
-				var ownFrames = GetCurrentRenderTreeFrames(rootComponentId);
-				for (var i = 0; i < ownFrames.Count; i++)
-				{
-					ref var frame = ref ownFrames.Array[i];
-					if (frame.FrameType == RenderTreeFrameType.Component)
-					{
-						if (frame.Component is TComponent component)
-							result.Add((frame.ComponentId, component));
-
-						GetComponentsInternal(frame.ComponentId, result);
-					}
-				}
+				_unhandledException = null;
+				var evt = new EventId(3, nameof(AssertNoUnhandledExceptions));
+				_logger.LogError(evt, unhandled, $"An unhandled exception happened during rendering: {unhandled.Message}{Environment.NewLine}{unhandled.StackTrace}");
+				ExceptionDispatchInfo.Capture(unhandled).Throw();
 			}
 		}
 	}
diff --git a/src/bunit.core/TestContextBase.cs b/src/bunit.core/TestContextBase.cs
index 3ccfff964..70e0126f7 100644
--- a/src/bunit.core/TestContextBase.cs
+++ b/src/bunit.core/TestContextBase.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Xml.Serialization;
 
 using Bunit.Rendering;
 
@@ -37,7 +38,12 @@ public ITestRenderer Renderer
 		public TestContextBase()
 		{
 			Services = new TestServiceProvider();
-			Services.AddSingleton<ITestRenderer>(srv => new TestRenderer(srv, srv.GetService<ILoggerFactory>() ?? NullLoggerFactory.Instance));
+			Services.AddSingleton<ITestRenderer>(srv =>
+			{
+				var rca = srv.GetRequiredService<IRenderedComponentActivator>();
+				var loggerFactory = srv.GetService<ILoggerFactory>() ?? NullLoggerFactory.Instance;
+				return new TestRenderer(rca, srv, loggerFactory);
+			});
 		}
 
 		/// <inheritdoc/>
diff --git a/src/bunit.web/Extensions/RenderedFragmentExtensions.cs b/src/bunit.web/Extensions/RenderedFragmentExtensions.cs
index 280979d91..bcb918b31 100644
--- a/src/bunit.web/Extensions/RenderedFragmentExtensions.cs
+++ b/src/bunit.web/Extensions/RenderedFragmentExtensions.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 
 using AngleSharp.Dom;
 
@@ -63,8 +64,7 @@ public static IRenderedComponent<TComponent> FindComponent<TComponent>(this IRen
 				throw new ArgumentNullException(nameof(renderedFragment));
 
 			var renderer = renderedFragment.Services.GetRequiredService<ITestRenderer>();
-			var (id, component) = renderer.FindComponent<TComponent>(renderedFragment.ComponentId);
-			return new RenderedComponent<TComponent>(renderedFragment.Services, id, component);
+			return (IRenderedComponent<TComponent>)renderer.FindComponent<TComponent>(renderedFragment);			
 		}
 
 		/// <summary>
@@ -79,15 +79,9 @@ public static IReadOnlyList<IRenderedComponent<TComponent>> FindComponents<TComp
 				throw new ArgumentNullException(nameof(renderedFragment));
 
 			var renderer = renderedFragment.Services.GetRequiredService<ITestRenderer>();
-			var components = renderer.FindComponents<TComponent>(renderedFragment.ComponentId);
-			var result = components.Count == 0 ? Array.Empty<IRenderedComponent<TComponent>>() : new IRenderedComponent<TComponent>[components.Count];
+			var components = renderer.FindComponents<TComponent>(renderedFragment);
 
-			for (int i = 0; i < components.Count; i++)
-			{
-				result[i] = new RenderedComponent<TComponent>(renderedFragment.Services, components[i].ComponentId, components[i].Component);
-			}
-
-			return result;
+			return components.Cast<IRenderedComponent<TComponent>>().ToArray();
 		}
 	}
 }
diff --git a/src/bunit.web/Extensions/TestServiceProviderExtensions.cs b/src/bunit.web/Extensions/TestServiceProviderExtensions.cs
index 3000071ec..955ed7570 100644
--- a/src/bunit.web/Extensions/TestServiceProviderExtensions.cs
+++ b/src/bunit.web/Extensions/TestServiceProviderExtensions.cs
@@ -28,6 +28,7 @@ public static IServiceCollection AddDefaultTestContextServices(this IServiceColl
 					srv.GetRequiredService<HtmlComparer>()
 				)
 			);
+			services.AddSingleton<IRenderedComponentActivator, RenderedComponentActivator>();
 			return services;
 		}
 	}
diff --git a/src/bunit.web/IRenderedFragment.cs b/src/bunit.web/IRenderedFragment.cs
index f0c43766a..e792cc230 100644
--- a/src/bunit.web/IRenderedFragment.cs
+++ b/src/bunit.web/IRenderedFragment.cs
@@ -4,6 +4,8 @@
 using AngleSharp.Diffing.Core;
 using AngleSharp.Dom;
 
+using Bunit.Rendering;
+
 namespace Bunit
 {
 	/// <summary>
@@ -11,16 +13,13 @@ namespace Bunit
 	/// </summary>
 	public interface IRenderedFragment : IRenderedFragmentBase
 	{
+		event Action OnMarkupUpdated;
+
 		/// <summary>
 		/// Gets the HTML markup from the rendered fragment/component.
 		/// </summary>
 		string Markup { get; }
 
-		/// <summary>
-		/// An event that is raised after the markup of the <see cref="IRenderedFragmentBase"/> is updated.
-		/// </summary>
-		event Action OnMarkupUpdated;
-
 		/// <summary>
 		/// Gets the AngleSharp <see cref="INodeList"/> based
 		/// on the HTML markup from the rendered fragment/component.
@@ -49,5 +48,7 @@ public interface IRenderedFragment : IRenderedFragmentBase
 		/// the snapshot and the rendered markup at that time.
 		/// </summary>
 		void SaveSnapshot();
+
+
 	}
 }
diff --git a/src/bunit.web/RazorTesting/Fixture.cs b/src/bunit.web/RazorTesting/Fixture.cs
index 5597f666c..977d2f732 100644
--- a/src/bunit.web/RazorTesting/Fixture.cs
+++ b/src/bunit.web/RazorTesting/Fixture.cs
@@ -6,6 +6,7 @@
 using Bunit.Extensions;
 using Bunit.RazorTesting;
 using Bunit.Rendering;
+
 using Microsoft.AspNetCore.Components;
 
 namespace Bunit
@@ -22,8 +23,9 @@ private IReadOnlyList<FragmentBase> TestData
 			{
 				if (_testData is null)
 				{
-					var id = Renderer.RenderFragment(ChildContent!);
-					_testData = Renderer.FindComponents<FragmentBase>(id).Select(x => x.Component).ToArray();
+					var renderedFragment = Renderer.RenderFragment(ChildContent!);
+					var comps = Renderer.FindComponents<FragmentBase>(renderedFragment);
+					_testData = comps.Select(x => x.Instance).ToArray();
 				}
 				return _testData;
 			}
@@ -124,15 +126,13 @@ private ComponentUnderTest SelectComponentUnderTest(string _)
 
 		private IRenderedComponent<TComponent> Factory<TComponent>(RenderFragment fragment) where TComponent : IComponent
 		{
-			var renderId = Renderer.RenderFragment(fragment);
-			var (componentId, component) = Renderer.FindComponent<TComponent>(renderId);
-			return new RenderedComponent<TComponent>(Services, componentId, component);
+			var renderedFragment = Renderer.RenderFragment(fragment);
+			return (IRenderedComponent<TComponent>)Renderer.FindComponent<TComponent>(renderedFragment);
 		}
 
 		private IRenderedFragment Factory(RenderFragment fragment)
 		{
-			var renderId = Renderer.RenderFragment(fragment);
-			return new RenderedFragment(Services, renderId);
+			return (IRenderedFragment)Renderer.RenderFragment(fragment);
 		}
 
 		private IRenderedComponent<TComponent> TryCastTo<TComponent>(IRenderedFragment target, [System.Runtime.CompilerServices.CallerMemberName] string sourceMethod = "") where TComponent : IComponent
diff --git a/src/bunit.web/RazorTesting/SnapshotTest.cs b/src/bunit.web/RazorTesting/SnapshotTest.cs
index 8c78f304e..6a7f39541 100644
--- a/src/bunit.web/RazorTesting/SnapshotTest.cs
+++ b/src/bunit.web/RazorTesting/SnapshotTest.cs
@@ -53,11 +53,11 @@ protected override async Task Run()
 			if (SetupAsync is { })
 				await TryRunAsync(SetupAsync, this).ConfigureAwait(false);
 
-			var testRenderId = Renderer.RenderFragment(TestInput!);
-			var inputHtml = Htmlizer.GetHtml(Renderer, testRenderId);
+			var renderedTestInput = (IRenderedFragment)Renderer.RenderFragment(TestInput!);
+			var inputHtml = renderedTestInput.Markup;
 
-			var expectedRenderId = Renderer.RenderFragment(ExpectedOutput!);
-			var expectedHtml = Htmlizer.GetHtml(Renderer, expectedRenderId);
+			var renderedExpectedRender = (IRenderedFragment)Renderer.RenderFragment(ExpectedOutput!);
+			var expectedHtml = renderedExpectedRender.Markup;
 
 			VerifySnapshot(inputHtml, expectedHtml);
 		}
diff --git a/src/bunit.web/Rendering/Internal/Htmlizer.cs b/src/bunit.web/Rendering/Internal/Htmlizer.cs
index 6dcab3555..e5ddc6eb3 100644
--- a/src/bunit.web/Rendering/Internal/Htmlizer.cs
+++ b/src/bunit.web/Rendering/Internal/Htmlizer.cs
@@ -16,7 +16,7 @@ namespace Bunit
 	/// https://source.dot.net/#Microsoft.AspNetCore.Mvc.ViewFeatures/RazorComponents/HtmlRenderer.cs
 	/// </summary>
 	[SuppressMessage("Usage", "BL0006:Do not use RenderTree types", Justification = "<Pending>")]
-	internal class Htmlizer
+	public static class Htmlizer
 	{
 		private static readonly HtmlEncoder HtmlEncoder = HtmlEncoder.Default;
 
@@ -39,10 +39,10 @@ public static string ToBlazorAttribute(string attributeName)
 			return $"{BLAZOR_ATTR_PREFIX}{attributeName}";
 		}
 
-		public static string GetHtml(ITestRenderer renderer, int componentId)
+		public static string GetHtml(int componentId, RenderTreeFrameCollection framesCollection)
 		{
-			var frames = renderer.GetCurrentRenderTreeFrames(componentId);
-			var context = new HtmlRenderingContext(renderer);
+			var context = new HtmlRenderingContext(framesCollection);
+			var frames = context.GetRenderTreeFrames(componentId);
 			var newPosition = RenderFrames(context, frames, 0, frames.Count);
 			Debug.Assert(newPosition == frames.Count, $"frames.Count = {frames.Count}. newPosition = {newPosition}");
 			return string.Join(string.Empty, context.Result);
@@ -101,7 +101,7 @@ private static int RenderChildComponent(
 			int position)
 		{
 			ref var frame = ref frames.Array[position];
-			var childFrames = context.Renderer.GetCurrentRenderTreeFrames(frame.ComponentId);
+			var childFrames = context.GetRenderTreeFrames(frame.ComponentId);
 			RenderFrames(context, childFrames, 0, childFrames.Count);
 			return position + frame.ComponentSubtreeLength;
 		}
@@ -264,13 +264,16 @@ private static int RenderAttributes(
 
 		private class HtmlRenderingContext
 		{
-			public ITestRenderer Renderer { get; }
+			private readonly RenderTreeFrameCollection _frames;
 
-			public HtmlRenderingContext(ITestRenderer renderer)
+			public HtmlRenderingContext(RenderTreeFrameCollection frames)
 			{
-				Renderer = renderer;
+				_frames = frames;
 			}
 
+			public ArrayRange<RenderTreeFrame> GetRenderTreeFrames(int componentId)
+				=> _frames[componentId];
+
 			public List<string> Result { get; } = new List<string>();
 
 			public string? ClosestSelectValueAsString { get; set; }
diff --git a/src/bunit.web/Rendering/Internal/NewHtmlizer.cs b/src/bunit.web/Rendering/Internal/NewHtmlizer.cs
deleted file mode 100644
index 495fc8a96..000000000
--- a/src/bunit.web/Rendering/Internal/NewHtmlizer.cs
+++ /dev/null
@@ -1,282 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
-using System.Text.Encodings.Web;
-
-using Bunit.Rendering;
-
-using Microsoft.AspNetCore.Components.RenderTree;
-
-namespace Bunit
-{
-	/// <summary>
-	/// This file is based on
-	/// https://source.dot.net/#Microsoft.AspNetCore.Mvc.ViewFeatures/RazorComponents/HtmlRenderer.cs
-	/// </summary>
-	[SuppressMessage("Usage", "BL0006:Do not use RenderTree types", Justification = "<Pending>")]
-	public static class HewHtmlizer
-	{
-		private static readonly HtmlEncoder HtmlEncoder = HtmlEncoder.Default;
-
-		private static readonly HashSet<string> SelfClosingElements = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
-		{
-			"area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"
-		};
-
-		private const string BLAZOR_INTERNAL_ATTR_PREFIX = "__internal_";
-		private const string BLAZOR_CSS_SCOPE_ATTR_PREFIX = "b-";
-		public const string BLAZOR_ATTR_PREFIX = "blazor:";
-		public const string ELEMENT_REFERENCE_ATTR_NAME = BLAZOR_ATTR_PREFIX + "elementreference";
-
-		public static bool IsBlazorAttribute(string attributeName)
-			=> attributeName.StartsWith(BLAZOR_ATTR_PREFIX, StringComparison.Ordinal) ||
-			   attributeName.StartsWith(BLAZOR_CSS_SCOPE_ATTR_PREFIX, StringComparison.Ordinal);
-
-		public static string ToBlazorAttribute(string attributeName)
-		{
-			return $"{BLAZOR_ATTR_PREFIX}{attributeName}";
-		}
-
-		public static string GetHtml(int componentId, RenderTreeFrameCollection framesCollection)
-		{
-			var context = new HtmlRenderingContext(framesCollection);
-			var frames = context.GetRenderTreeFrames(componentId);
-			var newPosition = RenderFrames(context, frames, 0, frames.Count);
-			Debug.Assert(newPosition == frames.Count, $"frames.Count = {frames.Count}. newPosition = {newPosition}");
-			return string.Join(string.Empty, context.Result);
-		}
-
-		private static int RenderFrames(HtmlRenderingContext context, ArrayRange<RenderTreeFrame> frames, int position, int maxElements)
-		{
-			var nextPosition = position;
-			var endPosition = position + maxElements;
-			while (position < endPosition)
-			{
-				nextPosition = RenderCore(context, frames, position);
-				if (position == nextPosition)
-				{
-					throw new InvalidOperationException("We didn't consume any input.");
-				}
-				position = nextPosition;
-			}
-
-			return nextPosition;
-		}
-
-		private static int RenderCore(
-			HtmlRenderingContext context,
-			ArrayRange<RenderTreeFrame> frames,
-			int position)
-		{
-			ref var frame = ref frames.Array[position];
-			switch (frame.FrameType)
-			{
-				case RenderTreeFrameType.Element:
-					return RenderElement(context, frames, position);
-				case RenderTreeFrameType.Attribute:
-					throw new InvalidOperationException($"Attributes should only be encountered within {nameof(RenderElement)}");
-				case RenderTreeFrameType.Text:
-					context.Result.Add(HtmlEncoder.Encode(frame.TextContent));
-					return ++position;
-				case RenderTreeFrameType.Markup:
-					context.Result.Add(frame.MarkupContent);
-					return ++position;
-				case RenderTreeFrameType.Component:
-					return RenderChildComponent(context, frames, position);
-				case RenderTreeFrameType.Region:
-					return RenderFrames(context, frames, position + 1, frame.RegionSubtreeLength - 1);
-				case RenderTreeFrameType.ElementReferenceCapture:
-				case RenderTreeFrameType.ComponentReferenceCapture:
-					return ++position;
-				default:
-					throw new InvalidOperationException($"Invalid element frame type '{frame.FrameType}'.");
-			}
-		}
-
-		private static int RenderChildComponent(
-			HtmlRenderingContext context,
-			ArrayRange<RenderTreeFrame> frames,
-			int position)
-		{
-			ref var frame = ref frames.Array[position];
-			var childFrames = context.GetRenderTreeFrames(frame.ComponentId);
-			RenderFrames(context, childFrames, 0, childFrames.Count);
-			return position + frame.ComponentSubtreeLength;
-		}
-
-		private static int RenderElement(
-			HtmlRenderingContext context,
-			ArrayRange<RenderTreeFrame> frames,
-			int position)
-		{
-			ref var frame = ref frames.Array[position];
-			var result = context.Result;
-			result.Add("<");
-			result.Add(frame.ElementName);
-			var afterAttributes = RenderAttributes(context, frames, position + 1, frame.ElementSubtreeLength - 1, out var capturedValueAttribute);
-
-			// When we see an <option> as a descendant of a <select>, and the option's "value" attribute matches the
-			// "value" attribute on the <select>, then we auto-add the "selected" attribute to that option. This is
-			// a way of converting Blazor's select binding feature to regular static HTML.
-			if (context.ClosestSelectValueAsString != null
-				&& string.Equals(frame.ElementName, "option", StringComparison.OrdinalIgnoreCase)
-				&& string.Equals(capturedValueAttribute, context.ClosestSelectValueAsString, StringComparison.Ordinal))
-			{
-				result.Add(" selected");
-			}
-
-			var remainingElements = frame.ElementSubtreeLength + position - afterAttributes;
-			if (remainingElements > 0)
-			{
-				result.Add(">");
-
-				var isSelect = string.Equals(frame.ElementName, "select", StringComparison.OrdinalIgnoreCase);
-				if (isSelect)
-				{
-					context.ClosestSelectValueAsString = capturedValueAttribute;
-				}
-
-				var afterElement = RenderChildren(context, frames, afterAttributes, remainingElements);
-
-				if (isSelect)
-				{
-					// There's no concept of nested <select> elements, so as soon as we're exiting one of them,
-					// we can safely say there is no longer any value for this
-					context.ClosestSelectValueAsString = null;
-				}
-
-				result.Add("</");
-				result.Add(frame.ElementName);
-				result.Add(">");
-				Debug.Assert(afterElement == position + frame.ElementSubtreeLength);
-				return afterElement;
-			}
-			else
-			{
-				if (SelfClosingElements.Contains(frame.ElementName))
-				{
-					result.Add(" />");
-				}
-				else
-				{
-					result.Add(">");
-					result.Add("</");
-					result.Add(frame.ElementName);
-					result.Add(">");
-				}
-				Debug.Assert(afterAttributes == position + frame.ElementSubtreeLength, $"afterAttributes = {afterAttributes}. position = {position}. frame.ElementSubtreeLength = {frame.ElementSubtreeLength}");
-				return afterAttributes;
-			}
-		}
-
-		private static int RenderChildren(HtmlRenderingContext context, ArrayRange<RenderTreeFrame> frames, int position, int maxElements)
-		{
-			if (maxElements == 0)
-			{
-				return position;
-			}
-
-			return RenderFrames(context, frames, position, maxElements);
-		}
-
-		private static int RenderAttributes(
-			HtmlRenderingContext context,
-			ArrayRange<RenderTreeFrame> frames, int position, int maxElements, out string? capturedValueAttribute)
-		{
-			capturedValueAttribute = null;
-
-			if (maxElements == 0)
-			{
-				return position;
-			}
-
-			var result = context.Result;
-
-			for (var i = 0; i < maxElements; i++)
-			{
-				var candidateIndex = position + i;
-				ref var frame = ref frames.Array[candidateIndex];
-
-				// Added to write ElementReferenceCaptureId to DOM
-				if (frame.FrameType == RenderTreeFrameType.ElementReferenceCapture)
-				{
-					result.Add($" {ELEMENT_REFERENCE_ATTR_NAME}=\"{frame.ElementReferenceCaptureId}\"");
-				}
-
-				if (frame.FrameType != RenderTreeFrameType.Attribute)
-				{
-					return candidateIndex;
-				}
-
-				if (frame.AttributeName.Equals("value", StringComparison.OrdinalIgnoreCase))
-				{
-					capturedValueAttribute = frame.AttributeValue as string;
-				}
-
-				if (frame.AttributeEventHandlerId > 0)
-				{
-					// NOTE: this was changed from  
-					//       result.Add($" {frame.AttributeName}=\"{frame.AttributeEventHandlerId}\"");
-					//       to the following to make it more obvious
-					//       that this is a generated/special blazor attribute
-					//       used for tracking event handler id's
-					result.Add(" ");
-					result.Add(BLAZOR_ATTR_PREFIX);
-					result.Add(frame.AttributeName);
-					result.Add("=");
-					result.Add("\"");
-					result.Add(frame.AttributeEventHandlerId.ToString(CultureInfo.InvariantCulture));
-					result.Add("\"");
-					continue;
-				}
-
-				switch (frame.AttributeValue)
-				{
-					case bool flag when flag && frame.AttributeName.StartsWith(BLAZOR_INTERNAL_ATTR_PREFIX, StringComparison.Ordinal):
-						// NOTE: This was added to make it more obvious
-						//       that this is a generated/special blazor attribute
-						//	     for internal usage                    
-						result.Add(" ");
-						result.Add(BLAZOR_ATTR_PREFIX);
-						result.Add(frame.AttributeName);
-						break;
-					case bool flag when flag:
-						result.Add(" ");
-						result.Add(frame.AttributeName);
-						break;
-					case string value:
-						result.Add(" ");
-						result.Add(frame.AttributeName);
-						result.Add("=");
-						result.Add("\"");
-						result.Add(HtmlEncoder.Encode(value));
-						result.Add("\"");
-						break;
-					default:
-						break;
-				}
-			}
-
-			return position + maxElements;
-		}
-
-		private class HtmlRenderingContext
-		{
-			private readonly RenderTreeFrameCollection _frames;
-
-			public HtmlRenderingContext(RenderTreeFrameCollection frames)
-			{
-				_frames = frames;
-			}
-
-			public ArrayRange<RenderTreeFrame> GetRenderTreeFrames(int componentId)
-				=> _frames[componentId];
-
-			public List<string> Result { get; } = new List<string>();
-
-			public string? ClosestSelectValueAsString { get; set; }
-		}
-	}
-}
diff --git a/src/bunit.web/Rendering/RenderedComponent.cs b/src/bunit.web/Rendering/RenderedComponent.cs
index 83a22f80b..6f5132d66 100644
--- a/src/bunit.web/Rendering/RenderedComponent.cs
+++ b/src/bunit.web/Rendering/RenderedComponent.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+
 using Microsoft.AspNetCore.Components;
 
 namespace Bunit.Rendering
@@ -9,7 +10,7 @@ namespace Bunit.Rendering
 	/// <inheritdoc/>
 	internal class RenderedComponent<TComponent> : RenderedFragment, IRenderedComponent<TComponent> where TComponent : IComponent
 	{
-		private readonly TComponent _instance;
+		private TComponent _instance = default!;
 
 		/// <inheritdoc/>
 		public TComponent Instance
@@ -17,13 +18,38 @@ public TComponent Instance
 			get
 			{
 				EnsureComponentNotDisposed();
-				return _instance;
+				return _instance ?? throw new InvalidOperationException("Component has not rendered yet...");
 			}
 		}
 
-		public RenderedComponent(IServiceProvider services, int componentId, TComponent component) : base(services, componentId)
+		public RenderedComponent(int componentId, IServiceProvider services) : base(componentId, services) { }
+
+		public RenderedComponent(int componentId, TComponent instance, RenderTreeFrameCollection componentFrames, IServiceProvider services) : base(componentId, services)
 		{
-			_instance = component;
+			_instance = instance;
+			RenderCount++;
+			UpdateMarkup(componentFrames);
+		}
+
+		protected override void OnRender(RenderEvent renderEvent)
+		{
+			if (_instance is null)
+			{
+				SetComponentAndID(renderEvent);
+			}
+		}
+
+		private void SetComponentAndID(RenderEvent renderEvent)
+		{			
+			if (renderEvent.Frames.TryFindComponent<TComponent>(ComponentId, out var id, out var component))
+			{
+				_instance = component;
+				ComponentId = id;
+			}
+			else
+			{
+				throw new InvalidOperationException("Component instance not found at expected position in render tree.");
+			}
 		}
 	}
 }
diff --git a/src/bunit.web/Rendering/RenderedComponentActivator.cs b/src/bunit.web/Rendering/RenderedComponentActivator.cs
new file mode 100644
index 000000000..a650dfc4a
--- /dev/null
+++ b/src/bunit.web/Rendering/RenderedComponentActivator.cs
@@ -0,0 +1,29 @@
+using System;
+
+using Microsoft.AspNetCore.Components;
+
+namespace Bunit.Rendering
+{
+	public sealed class RenderedComponentActivator : IRenderedComponentActivator
+	{
+		private readonly IServiceProvider _services;
+
+		public RenderedComponentActivator(IServiceProvider services)
+		{
+			_services = services;
+		}
+
+		/// <inheritdoc/>
+		public IRenderedFragmentBase CreateRenderedComponent(int componentId)
+			=> new RenderedFragment(componentId, _services);
+
+		/// <inheritdoc/>
+		public IRenderedComponentBase<TComponent> CreateRenderedComponent<TComponent>(int componentId) where TComponent : IComponent
+			=> new RenderedComponent<TComponent>(componentId, _services);
+
+		/// <inheritdoc/>
+		public IRenderedComponentBase<TComponent> CreateRenderedComponent<TComponent>(int componentId, TComponent component, RenderTreeFrameCollection componentFrames)
+			where TComponent : IComponent
+			=> new RenderedComponent<TComponent>(componentId, component, componentFrames, _services);
+	}
+}
diff --git a/src/bunit.web/Rendering/RenderedFragment.cs b/src/bunit.web/Rendering/RenderedFragment.cs
index 7c45fee5c..60df253c9 100644
--- a/src/bunit.web/Rendering/RenderedFragment.cs
+++ b/src/bunit.web/Rendering/RenderedFragment.cs
@@ -14,45 +14,34 @@
 
 namespace Bunit.Rendering
 {
-	/// <summary>
-	/// Represents an abstract <see cref="IRenderedFragment"/> with base functionality.
-	/// </summary>
-	public class RenderedFragment : IRenderedFragment, IRenderEventHandler
+	internal class RenderedFragment : IRenderedFragment
 	{
 		private readonly object _markupAccessLock = new object();
-		private readonly ILogger<RenderedFragment> _logger;
+		private readonly HtmlParser _htmlParser;
+		private string _markup = string.Empty;
 		private string? _snapshotMarkup;
+
 		private INodeList? _firstRenderNodes;
 		private INodeList? _latestRenderNodes;
 		private INodeList? _snapshotNodes;
-		private string _markup;
-		private bool _componentDisposed;
-
-		private HtmlParser HtmlParser { get; }
 
 		/// <summary>
 		/// Gets the first rendered markup.
 		/// </summary>
-		protected string FirstRenderMarkup { get; }
+		protected string FirstRenderMarkup { get; private set; }
 
-		/// <inheritdoc/>
-		public ITestRenderer Renderer { get; }
+		public event Action? OnAfterRender;
+		public event Action? OnMarkupUpdated;
 
-		/// <inheritdoc/>
-		public IServiceProvider Services { get; }
+		public bool IsDisposed { get; private set; }
 
-		/// <inheritdoc/>
-		public int ComponentId { get; }
+		public int ComponentId { get; protected set; }
 
-		/// <inheritdoc/>
 		public string Markup
 		{
 			get
 			{
 				EnsureComponentNotDisposed();
-
-				// The lock ensures that we cannot read the _markup and _latestRenderNodes
-				// field while it is being updated
 				lock (_markupAccessLock)
 				{
 					return Volatile.Read(ref _markup);
@@ -60,7 +49,8 @@ public string Markup
 			}
 		}
 
-		/// <inheritdoc/>
+		public int RenderCount { get; protected set; }
+
 		public INodeList Nodes
 		{
 			get
@@ -71,129 +61,110 @@ public INodeList Nodes
 				lock (_markupAccessLock)
 				{
 					if (_latestRenderNodes is null)
-						_latestRenderNodes = HtmlParser.Parse(Markup);
+						_latestRenderNodes = _htmlParser.Parse(Markup);
+
 					return _latestRenderNodes;
 				}
 			}
 		}
 
-		/// <inheritdoc/>
-		public event Action? OnMarkupUpdated;
-
-		/// <inheritdoc/>
-		public event Action? OnAfterRender;
-
-		/// <inheritdoc/>
-		public int RenderCount { get; private set; }
+		public IServiceProvider Services { get; }
 
-		/// <summary>
-		/// Creates an instance of the <see cref="RenderedFragment"/> class.
-		/// </summary>
-		public RenderedFragment(IServiceProvider services, int componentId)
+		public RenderedFragment(int componentId, IServiceProvider service)
 		{
-			if (services is null)
-				throw new ArgumentNullException(nameof(services));
-
-			_logger = services.CreateLogger<RenderedFragment>();
-			HtmlParser = services.GetRequiredService<HtmlParser>();
-			Renderer = services.GetRequiredService<ITestRenderer>();
-			Services = services;
 			ComponentId = componentId;
-			_markup = RetrieveLatestMarkupFromRenderer();
-			FirstRenderMarkup = _markup;
-			Renderer.AddRenderEventHandler(this);
-			RenderCount = 1;
+			Services = service;
+			_htmlParser = Services.GetRequiredService<HtmlParser>();
 		}
 
-		/// <inheritdoc/>
-		public void SaveSnapshot()
+		public IReadOnlyList<IDiff> GetChangesSinceFirstRender()
 		{
-			_snapshotNodes = null;
-			_snapshotMarkup = Markup;
+			if (_firstRenderNodes is null)
+				_firstRenderNodes = _htmlParser.Parse(FirstRenderMarkup);
+
+			return Nodes.CompareTo(_firstRenderNodes);
 		}
 
-		/// <inheritdoc/>
 		public IReadOnlyList<IDiff> GetChangesSinceSnapshot()
 		{
 			if (_snapshotMarkup is null)
-				throw new InvalidOperationException($"No snapshot exists to compare with. Call {nameof(SaveSnapshot)} to create one.");
+				throw new InvalidOperationException($"No snapshot exists to compare with. Call {nameof(SaveSnapshot)}() to create one.");
 
 			if (_snapshotNodes is null)
-				_snapshotNodes = HtmlParser.Parse(_snapshotMarkup);
+				_snapshotNodes = _htmlParser.Parse(_snapshotMarkup);
 
 			return Nodes.CompareTo(_snapshotNodes);
 		}
 
-		/// <inheritdoc/>
-		public IReadOnlyList<IDiff> GetChangesSinceFirstRender()
-		{
-			if (_firstRenderNodes is null)
-				_firstRenderNodes = HtmlParser.Parse(FirstRenderMarkup);
-			return Nodes.CompareTo(_firstRenderNodes);
-		}
-
-		private string RetrieveLatestMarkupFromRenderer() => Htmlizer.GetHtml(Renderer, ComponentId);
-
-		Task IRenderEventHandler.Handle(RenderEvent renderEvent)
+		public void SaveSnapshot()
 		{
-			if (renderEvent.DidComponentDispose(ComponentId))
-			{
-				HandleComponentDisposed();
-			}
-			else if (renderEvent.DidComponentRender(ComponentId))
-			{
-				HandleComponentRender(renderEvent);
-			}
-			return Task.CompletedTask;
+			_snapshotNodes = null;
+			_snapshotMarkup = Markup;
 		}
 
-		private void HandleComponentRender(RenderEvent renderEvent)
+		void IRenderedFragmentBase.OnRender(RenderEvent renderEvent)
 		{
-			_logger.LogDebug(new EventId(1, nameof(HandleComponentRender)), $"Received a new render where component {ComponentId} did render.");
-
-			RenderCount++;
+			if (IsDisposed)
+				return;
 
-			// First notify derived types, e.g. queried AngleSharp collections or elements
-			// that the markup has changed and they should rerun their queries.
-			HandleChangesToMarkup(renderEvent);
+			var (rendered, changed, disposed) = renderEvent.GetRenderStatus(this);
 
-			// Then it is safe to tell anybody waiting on updates or changes to the rendered fragment
-			// that they can redo their assertions or continue processing.
-			OnAfterRender?.Invoke();
-		}
+			if (disposed)
+			{
+				((IDisposable)this).Dispose();
+				return;
+			}
 
-		private void HandleChangesToMarkup(RenderEvent renderEvent)
-		{
-			if (renderEvent.HasMarkupChanges(ComponentId))
+			lock (_markupAccessLock)
 			{
-				_logger.LogDebug(new EventId(1, nameof(HandleChangesToMarkup)), $"Received a new render where the markup of component {ComponentId} changed.");
+				if (rendered)
+				{
+					OnRender(renderEvent);
+					RenderCount++;
+				}
 
-				// The lock ensures that latest nodes is always based on the latest rendered markup.
-				lock (_markupAccessLock)
+				if (changed)
 				{
-					_latestRenderNodes = null;
-					_markup = RetrieveLatestMarkupFromRenderer();
+					UpdateMarkup(renderEvent.Frames);
 				}
+			}
 
+			if (rendered)
+				OnAfterRender?.Invoke();
+			if (changed)
 				OnMarkupUpdated?.Invoke();
-			}
 		}
 
-		private void HandleComponentDisposed()
+		protected void UpdateMarkup(RenderTreeFrameCollection framesCollection)
 		{
-			_logger.LogDebug(new EventId(1, nameof(HandleChangesToMarkup)), $"Received a new render where the component {ComponentId} was disposed.");
-			_componentDisposed = true;
-			Renderer.RemoveRenderEventHandler(this);
+			lock (_markupAccessLock)
+			{
+				_latestRenderNodes = null;
+				var newMarkup = Htmlizer.GetHtml(ComponentId, framesCollection);
+				Volatile.Write(ref _markup, newMarkup);
+				if (RenderCount == 1)
+					FirstRenderMarkup = newMarkup;
+			}
 		}
 
+		protected virtual void OnRender(RenderEvent renderEvent) { }
+
 		/// <summary>
 		/// Ensures that the underlying component behind the
 		/// fragment has not been removed from the render tree.
 		/// </summary>
 		protected void EnsureComponentNotDisposed()
 		{
-			if (_componentDisposed)
+			if (IsDisposed)
 				throw new ComponentDisposedException(ComponentId);
 		}
+
+		void IDisposable.Dispose()
+		{
+			IsDisposed = true;
+			_markup = string.Empty;
+			OnAfterRender = null;
+			FirstRenderMarkup = string.Empty;
+		}
 	}
 }
diff --git a/src/bunit.web/TestContext.cs b/src/bunit.web/TestContext.cs
index cbdf6db65..e0e91684d 100644
--- a/src/bunit.web/TestContext.cs
+++ b/src/bunit.web/TestContext.cs
@@ -28,8 +28,8 @@ public TestContext()
 		/// <returns>The rendered <typeparamref name="TComponent"/></returns>
 		public IRenderedComponent<TComponent> RenderComponent<TComponent>(params ComponentParameter[] parameters) where TComponent : IComponent
 		{
-			var renderResult = Renderer.RenderComponent<TComponent>(parameters);
-			return new RenderedComponent<TComponent>(Services, renderResult.ComponentId, renderResult.Component);
+			var renderedFragment = Renderer.RenderComponent<TComponent>(parameters);
+			return (IRenderedComponent<TComponent>)renderedFragment;
 		}
 
 		/// <summary>
@@ -45,8 +45,8 @@ public virtual IRenderedComponent<TComponent> RenderComponent<TComponent>(Action
 
 			var builder = new ComponentParameterBuilder<TComponent>();
 			parameterBuilder(builder);
-			var renderResult = Renderer.RenderComponent<TComponent>(builder.Build());
-			return new RenderedComponent<TComponent>(Services, renderResult.ComponentId, renderResult.Component);
+			var renderedFragment = Renderer.RenderComponent<TComponent>(builder.Build());
+			return (IRenderedComponent<TComponent>)renderedFragment;
 		}
 	}
 }
diff --git a/tests/bunit.core.tests/ComponentParameterFactoryTest.cs b/tests/bunit.core.tests/ComponentParameterFactoryTest.cs
index 150cbf806..f025a737b 100644
--- a/tests/bunit.core.tests/ComponentParameterFactoryTest.cs
+++ b/tests/bunit.core.tests/ComponentParameterFactoryTest.cs
@@ -1,10 +1,12 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
+
 using Bunit.Rendering;
 using Bunit.TestAssets.SampleComponents;
 using Bunit.TestDoubles.JSInterop;
 
+using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Rendering;
 
 using Shouldly;
@@ -17,6 +19,12 @@ namespace Bunit
 {
 	public class ComponentParameterFactoryTest : TestContext
 	{
+		string GetMarkupFromRenderFragment(RenderFragment renderFragment)
+		{
+			return ((IRenderedFragment)Renderer.RenderFragment(renderFragment)).Markup;
+		}
+
+
 		[Fact(DisplayName = "All types of parameters are correctly assigned to component on render")]
 		public void Test005()
 		{
@@ -43,8 +51,8 @@ public void Test005()
 			Should.Throw<Exception>(async () => await instance.NonGenericCallback.InvokeAsync(EventArgs.Empty)).Message.ShouldBe("NonGenericCallback");
 			Should.Throw<Exception>(async () => await instance.GenericCallback.InvokeAsync(EventArgs.Empty)).Message.ShouldBe("GenericCallback");
 
-			new RenderedFragment(Services, Renderer.RenderFragment(instance.ChildContent!)).Markup.ShouldBe(nameof(ChildContent));
-			new RenderedFragment(Services, Renderer.RenderFragment(instance.OtherContent!)).Markup.ShouldBe(nameof(AllTypesOfParams<string>.OtherContent));
+			GetMarkupFromRenderFragment(instance.ChildContent!).ShouldBe(nameof(ChildContent));
+			GetMarkupFromRenderFragment(instance.OtherContent!).ShouldBe(nameof(AllTypesOfParams<string>.OtherContent));
 			Should.Throw<Exception>(() => instance.ItemTemplate!("")(new RenderTreeBuilder())).Message.ShouldBe("ItemTemplate");
 		}
 
@@ -82,8 +90,8 @@ public void Test002()
 			instance.RegularParam.ShouldBe("some value");
 			Should.Throw<Exception>(async () => await instance.NonGenericCallback.InvokeAsync(EventArgs.Empty)).Message.ShouldBe("NonGenericCallback");
 			Should.Throw<Exception>(async () => await instance.GenericCallback.InvokeAsync(EventArgs.Empty)).Message.ShouldBe("GenericCallback");
-			new RenderedFragment(Services, Renderer.RenderFragment(instance.ChildContent!)).Markup.ShouldBe(nameof(ChildContent));
-			new RenderedFragment(Services, Renderer.RenderFragment(instance.OtherContent!)).Markup.ShouldBe(nameof(AllTypesOfParams<string>.OtherContent));
+			GetMarkupFromRenderFragment(instance.ChildContent!).ShouldBe(nameof(ChildContent));
+			GetMarkupFromRenderFragment(instance.OtherContent!).ShouldBe(nameof(AllTypesOfParams<string>.OtherContent));
 			Should.Throw<Exception>(() => instance.ItemTemplate!("")(new RenderTreeBuilder())).Message.ShouldBe("ItemTemplate");
 		}
 
diff --git a/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs b/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs
index fa9a61597..f3a2847b2 100644
--- a/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs
+++ b/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs
@@ -15,6 +15,8 @@
 using Shouldly;
 using static Bunit.ComponentParameterFactory;
 using Xunit;
+using Bunit.Extensions;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Bunit.Rendering
 {
@@ -81,148 +83,35 @@ protected override void BuildRenderTree(RenderTreeBuilder builder)
 		}
 	}
 
-	internal class TestRenderedFragment : IRenderedComponent
+	internal static class TestRendererExtensions
 	{
-		private readonly object _markupAccessLock = new object();
-		private string _markup = string.Empty;
-
-		public bool IsDisposed { get; private set; }
-
-		public int ComponentId { get; protected set; }
-
-		public string Markup
-		{
-			get
-			{
-				if (IsDisposed)
-					throw new ComponentDisposedException(ComponentId);
-
-				lock (_markupAccessLock)
-				{
-					return _markup;
-				}
-			}
-		}
-
-		public int RenderCount { get; protected set; }
-
-		public TestRenderedFragment(int componentId)
-		{
-			ComponentId = componentId;
-		}
-
-		void IRenderedComponent.OnRender(NewRenderEvent renderEvent)
-		{
-			if (IsDisposed)
-				return;
-
-			lock (_markupAccessLock)
-			{
-				var (rendered, changed, disposed) = renderEvent.GetRenderStatus(this);
-
-				if (disposed)
-				{
-					((IDisposable)this).Dispose();
-					return;
-				}
-
-				if (rendered)
-				{
-					OnRender(renderEvent);
-					RenderCount++;
-
-					if (changed)
-						UpdateMarkup(renderEvent.Frames);
-				}
-			}
-		}
-		
-		void IDisposable.Dispose()
-		{
-			IsDisposed = true;
-			_markup = string.Empty;
-		}
-
-		protected void UpdateMarkup(RenderTreeFrameCollection framesCollection)
+		public static IRenderedComponent<TComponent> RenderComponent<TComponent>(this ITestRenderer renderer, params ComponentParameter[] parameters)
+			where TComponent : IComponent
 		{
-			lock (_markupAccessLock)
-			{
-				_markup = HewHtmlizer.GetHtml(ComponentId, framesCollection);
-			}
+			return (IRenderedComponent<TComponent>)renderer.RenderComponent<TComponent>(parameters);
 		}
-
-		protected virtual void OnRender(NewRenderEvent renderEvent) { }
 	}
 
-	internal class TestRenderedComponent<TComponent> : TestRenderedFragment where TComponent : IComponent
+	public class NewTestRendererTest
 	{
-		private TComponent _instance = default!;
-
-		public TComponent Instance => _instance ?? throw new InvalidOperationException("Component has not rendered yet...");
-
-		public TestRenderedComponent(int componentId) : base(componentId)
-		{
-		}
+		private TestServiceProvider Services { get; }
 
-		public TestRenderedComponent(int componentId, TComponent instance, RenderTreeFrameCollection componentFrames) : base(componentId)
+		public NewTestRendererTest()
 		{
-			_instance = instance;
-			RenderCount++;
-			UpdateMarkup(componentFrames);
-		}
-
-		protected override void OnRender(NewRenderEvent renderEvent)
-		{
-			if (_instance is null)
-			{
-				SetComponentAndID(renderEvent);
-			}
-		}
-
-		private void SetComponentAndID(NewRenderEvent renderEvent)
-		{
-			var frames = renderEvent.Frames[ComponentId];
-			if (frames.Array[0].Component is TComponent wrapperComponent)
+			Services = new TestServiceProvider();
+			Services.AddDefaultTestContextServices();
+			Services.AddSingleton<ITestRenderer>(srv =>
 			{
-				_instance = wrapperComponent;
-				ComponentId = frames.Array[0].ComponentId;
-			}
-			else
-			{
-				throw new InvalidOperationException("Component instance not found at expected position in render tree.");
-			}
+				var rca = srv.GetRequiredService<IRenderedComponentActivator>();
+				var loggerFactory = srv.GetService<ILoggerFactory>() ?? NullLoggerFactory.Instance;
+				return new TestRenderer(rca, srv, loggerFactory);
+			});
 		}
-	}
-
-	internal sealed class TestRenderedComponentActivator : IRenderedComponentActivator
-	{
-		public IRenderedComponent CreateRenderedComponent<T>(int componentId) where T : IComponent
-			=> new TestRenderedComponent<T>(componentId);
-		public IRenderedComponent CreateRenderedComponent(int componentId)
-			=> new TestRenderedFragment(componentId);
-		public IRenderedComponent CreateRenderedComponent<T>(int componentId, T component, RenderTreeFrameCollection componentFrames) where T : IComponent
-			=> new TestRenderedComponent<T>(componentId, component, componentFrames);
-	}
-
-	internal static class TestRendererExtensions
-	{
-		public static TestRenderedComponent<TComponent> RenderComponent<TComponent>(this NewTestRenderer renderer, params ComponentParameter[] parameters)
-			where TComponent : IComponent
-		{
-			return (TestRenderedComponent<TComponent>)renderer.RenderComponent<TComponent>(parameters);
-		}
-	}
-
-	public class NewTestRendererTest
-	{
-		private ILoggerFactory LoggerFactory { get; } = NullLoggerFactory.Instance;
-		private TestServiceProvider Services { get; } = new TestServiceProvider();
-		private IRenderedComponentActivator Activator { get; } = new TestRenderedComponentActivator();
 
 		[Fact(DisplayName = "RenderFragment re-throws exception from component")]
 		public void Test004()
 		{
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 			RenderFragment thowingFragment = b => { b.OpenComponent<ThrowsDuringSetParams>(0); b.CloseComponent(); };
 
 			Should.Throw<InvalidOperationException>(() => sut.RenderFragment(thowingFragment))
@@ -232,7 +121,7 @@ public void Test004()
 		[Fact(DisplayName = "RenderComponent re-throws exception from component")]
 		public void Test003()
 		{
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 
 			Should.Throw<InvalidOperationException>(() => sut.RenderComponent<ThrowsDuringSetParams>())
 				.Message.ShouldBe(ThrowsDuringSetParams.EXCEPTION.Message);
@@ -242,9 +131,9 @@ public void Test003()
 		public void Test001()
 		{
 			const string MARKUP = "<h1>hello world</h1>";
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 
-			var cut = (TestRenderedFragment)sut.RenderFragment(builder => builder.AddMarkupContent(0, MARKUP));
+			var cut = (IRenderedFragment)sut.RenderFragment(builder => builder.AddMarkupContent(0, MARKUP));
 
 			cut.RenderCount.ShouldBe(1);
 			cut.Markup.ShouldBe(MARKUP);
@@ -253,7 +142,7 @@ public void Test001()
 		[Fact(DisplayName = "Can render component without children and no parameters")]
 		public void Test002()
 		{
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 
 			var cut = sut.RenderComponent<NoChildNoParams>();
 
@@ -266,7 +155,7 @@ public void Test002()
 		public void Test005()
 		{
 			const string VALUE = "FOO BAR";
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 
 			var cut = sut.RenderComponent<HasParams>((nameof(HasParams.Value), VALUE));
 
@@ -279,7 +168,7 @@ public void Test006()
 			const string PARENT_VALUE = "PARENT";
 			const string CHILD_VALUE = "CHILD";
 
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 
 			var cut = sut.RenderComponent<HasParams>(
 				(nameof(HasParams.Value), PARENT_VALUE),
@@ -293,7 +182,7 @@ public void Test006()
 		[Fact(DisplayName = "Rendered component gets RenderCount updated on re-render")]
 		public async Task Test010()
 		{
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 
 			var cut = sut.RenderComponent<RenderTrigger>();
 
@@ -308,7 +197,7 @@ public async Task Test010()
 		public async Task Test011()
 		{
 			const string EXPECTED = "NOW VALUE";
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 
 			var cut = sut.RenderComponent<RenderTrigger>();
 
@@ -327,7 +216,7 @@ public void Test020()
 			const string PARENT_VALUE = "PARENT";
 			const string CHILD_VALUE = "CHILD";
 
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 
 			var cut = sut.RenderComponent<HasParams>(
 				(nameof(HasParams.Value), PARENT_VALUE),
@@ -335,7 +224,7 @@ public void Test020()
 			);
 
 			// act
-			var childCut = (TestRenderedComponent<HasParams>)sut.FindComponent<HasParams>(cut);
+			var childCut = (IRenderedComponent<HasParams>)sut.FindComponent<HasParams>(cut);
 
 			// assert
 			childCut.Markup.ShouldBe(CHILD_VALUE);
@@ -345,7 +234,7 @@ public void Test020()
 		[Fact(DisplayName = "FindComponent throws if parentComponent parameter is null")]
 		public void Test021()
 		{
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 
 			Should.Throw<ArgumentNullException>(() => sut.FindComponent<HasParams>(null!));
 		}
@@ -353,7 +242,7 @@ public void Test021()
 		[Fact(DisplayName = "FindComponent throws if component is not found")]
 		public void Test022()
 		{
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 			var cut = sut.RenderComponent<HasParams>();
 
 			Should.Throw<ComponentNotFoundException>(() => sut.FindComponent<HasParams>(cut));
@@ -367,8 +256,7 @@ public void Test030()
 			const string PARENT_VALUE = nameof(PARENT_VALUE);
 			const string CHILD_VALUE = nameof(CHILD_VALUE);
 
-
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 
 			var cut = sut.RenderComponent<HasParams>(
 				(nameof(HasParams.Value), GRAND_PARENT_VALUE),
@@ -382,7 +270,7 @@ public void Test030()
 
 			// act
 			var childCuts = sut.FindComponents<HasParams>(cut)
-				.Cast<TestRenderedComponent<HasParams>>()
+				.Cast<IRenderedComponent<HasParams>>()
 				.ToArray();
 
 			// assert
@@ -396,7 +284,7 @@ public void Test030()
 		[Fact(DisplayName = "FindComponents throws if parentComponent parameter is null")]
 		public void Test031()
 		{
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 
 			Should.Throw<ArgumentNullException>(() => sut.FindComponents<HasParams>(null!));
 		}
@@ -404,14 +292,14 @@ public void Test031()
 		[Fact(DisplayName = "Retrieved rendered child component with FindComponent gets updated on re-render")]
 		public async Task Test040()
 		{
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 
 			var parent = sut.RenderComponent<HasParams>(
 				ChildContent<RenderTrigger>()
 			);
 
 			// act
-			var cut = (TestRenderedComponent<RenderTrigger>)sut.FindComponent<RenderTrigger>(parent);
+			var cut = (IRenderedComponent<RenderTrigger>)sut.FindComponent<RenderTrigger>(parent);
 
 			cut.RenderCount.ShouldBe(1);
 
@@ -424,14 +312,14 @@ public async Task Test040()
 		[Fact(DisplayName = "Retrieved rendered child component with FindComponents gets updated on re-render")]
 		public async Task Test041()
 		{
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 
 			var parent = sut.RenderComponent<HasParams>(
 				ChildContent<RenderTrigger>()
 			);
 
 			// act
-			var cut = (TestRenderedComponent<RenderTrigger>)sut.FindComponents<RenderTrigger>(parent).Single();
+			var cut = (IRenderedComponent<RenderTrigger>)sut.FindComponents<RenderTrigger>(parent).Single();
 
 			cut.RenderCount.ShouldBe(1);
 
@@ -445,12 +333,12 @@ public async Task Test041()
 		public async Task Test050()
 		{
 			// arrange
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 
 			var cut = sut.RenderComponent<HasParams>(
 				ChildContent<RenderTrigger>()
 			);
-			var child = (TestRenderedComponent<RenderTrigger>)sut.FindComponent<RenderTrigger>(cut);
+			var child = (IRenderedComponent<RenderTrigger>)sut.FindComponent<RenderTrigger>(cut);
 
 			// act
 			await child.Instance.TriggerWithValue("X");
@@ -464,12 +352,12 @@ public async Task Test050()
 		public async Task Test060()
 		{
 			// arrange
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 
 			var cut = sut.RenderComponent<ToggleChild>(
 				ChildContent<NoChildNoParams>()
 			);
-			var child = (TestRenderedComponent<NoChildNoParams>)sut.FindComponent<NoChildNoParams>(cut);
+			var child = (IRenderedComponent<NoChildNoParams>)sut.FindComponent<NoChildNoParams>(cut);
 
 			// act
 			await cut.Instance.DisposeChild();
@@ -483,15 +371,15 @@ public async Task Test060()
 		public async Task Test061()
 		{
 			// arrange
-			using var sut = new NewTestRenderer(Activator, Services, LoggerFactory);
+			var sut = Services.GetRequiredService<ITestRenderer>();
 
 			var cut = sut.RenderComponent<ToggleChild>(
 				ChildContent<ToggleChild>(
 					ChildContent<NoChildNoParams>()
 				)
 			);
-			var child = (TestRenderedComponent<ToggleChild>)sut.FindComponent<ToggleChild>(cut);
-			var childChild = (TestRenderedComponent<NoChildNoParams>)sut.FindComponent<NoChildNoParams>(cut);
+			var child = (IRenderedComponent<ToggleChild>)sut.FindComponent<ToggleChild>(cut);
+			var childChild = (IRenderedComponent<NoChildNoParams>)sut.FindComponent<NoChildNoParams>(cut);
 
 			// act
 			await child.Instance.DisposeChild();
@@ -504,11 +392,11 @@ public async Task Test061()
 		[Fact(DisplayName = "When test renderer is disposed, so is all rendered components")]
 		public void Test070()
 		{
-			TestRenderedComponent<NoChildNoParams> cut;
-			using (var sut = new NewTestRenderer(Activator, Services, LoggerFactory))
-			{
-				cut = sut.RenderComponent<NoChildNoParams>();
-			}
+			var sut = (TestRenderer)Services.GetRequiredService<ITestRenderer>();
+			var cut = sut.RenderComponent<NoChildNoParams>();
+
+			sut.Dispose();
+
 			cut.IsDisposed.ShouldBeTrue();
 		}
 	}
diff --git a/tests/bunit.core.tests/Rendering/TestRendererTest.cs b/tests/bunit.core.tests/Rendering/TestRendererTest.cs
index f5967cce9..3c6518e49 100644
--- a/tests/bunit.core.tests/Rendering/TestRendererTest.cs
+++ b/tests/bunit.core.tests/Rendering/TestRendererTest.cs
@@ -18,58 +18,6 @@ public class TestRendererTest
 	{
 		private static readonly ServiceProvider ServiceProvider = new ServiceCollection().BuildServiceProvider();
 
-		[Fact(DisplayName = "Renderer notifies handlers of render events")]
-		public async Task Test001()
-		{
-			// Arrange
-			using var sut = new TestRenderer(ServiceProvider, NullLoggerFactory.Instance);
-			var handler = new MockRenderEventHandler(completeHandleTaskSynchronously: true);
-			sut.AddRenderEventHandler(handler);
-
-			// Act #1
-			var cut = sut.RenderComponent<Simple1>(Array.Empty<ComponentParameter>());
-
-			// Assert #1
-			handler.ReceivedEvents.Count.ShouldBe(1);
-
-			// Act #2
-			await sut.Dispatcher.InvokeAsync(() => cut.Component.SetParametersAsync(ParameterView.Empty));
-
-			// Assert #2
-			handler.ReceivedEvents.Count.ShouldBe(2);
-		}
-
-		[Fact(DisplayName = "Multiple handlers can be added to the Renderer")]
-		public void Test002()
-		{
-			using var sut = new TestRenderer(ServiceProvider, NullLoggerFactory.Instance);
-			var handler1 = new MockRenderEventHandler(completeHandleTaskSynchronously: true);
-			var handler2 = new MockRenderEventHandler(completeHandleTaskSynchronously: true);
-
-			sut.AddRenderEventHandler(handler1);
-			sut.AddRenderEventHandler(handler2);
-
-			sut.RenderComponent<Simple1>(Array.Empty<ComponentParameter>());
-			handler1.ReceivedEvents.Count.ShouldBe(1);
-			handler2.ReceivedEvents.Count.ShouldBe(1);
-		}
-
-		[Fact(DisplayName = "Handler is not invoked if removed from Renderer")]
-		public void Test003()
-		{
-			using var sut = new TestRenderer(ServiceProvider, NullLoggerFactory.Instance);
-			var handler1 = new MockRenderEventHandler(completeHandleTaskSynchronously: true);
-			var handler2 = new MockRenderEventHandler(completeHandleTaskSynchronously: true);
-			sut.AddRenderEventHandler(handler1);
-			sut.AddRenderEventHandler(handler2);
-
-			sut.RemoveRenderEventHandler(handler1);
-
-			sut.RenderComponent<Simple1>(Array.Empty<ComponentParameter>());
-			handler1.ReceivedEvents.ShouldBeEmpty();
-			handler2.ReceivedEvents.Count.ShouldBe(1);
-		}
-
 		[Fact(DisplayName = "Can render component that awaits uncompleted task in OnInitializedAsync")]
 		public void Test100()
 		{
@@ -106,36 +54,5 @@ public void Test102()
 
 			cut.Find("h1").TextContent.ShouldBe("SECOND");
 		}
-
-		class MockRenderEventHandler : IRenderEventHandler
-		{
-			private TaskCompletionSource<object?> _handleTask = new TaskCompletionSource<object?>();
-			private readonly bool _completeHandleTaskSynchronously;
-
-			public List<RenderEvent> ReceivedEvents { get; set; } = new List<RenderEvent>();
-
-			public MockRenderEventHandler(bool completeHandleTaskSynchronously)
-			{
-				if (completeHandleTaskSynchronously)
-					SetCompleted();
-				_completeHandleTaskSynchronously = completeHandleTaskSynchronously;
-			}
-
-			public Task Handle(RenderEvent renderEvent)
-			{
-				ReceivedEvents.Add(renderEvent);
-				return _handleTask.Task;
-			}
-
-			public void SetCompleted()
-			{
-				if (_completeHandleTaskSynchronously)
-					return;
-
-				var existing = _handleTask;
-				_handleTask = new TaskCompletionSource<object?>();
-				existing.SetResult(null);
-			}
-		}
 	}
 }
diff --git a/tests/run-tests.ps1 b/tests/run-tests.ps1
new file mode 100644
index 000000000..95e7ff1e1
--- /dev/null
+++ b/tests/run-tests.ps1
@@ -0,0 +1,19 @@
+$maxRuns = $args[0]
+$mode = $args[1]
+$filter = $args[2]
+
+dotnet build ..\bunit.sln -c $mode --nologo
+
+for ($num = 1 ; $num -le $maxRuns ; $num++)
+{
+    Write-Output "### TEST RUN $num ###"
+	
+	if($filter)
+	{
+		dotnet test ..\bunit.sln -c $mode --no-restore --no-build --blame-hang --blame-hang-timeout 100s -f net5.0 --nologo --filter $filter
+	}
+	else
+	{
+		dotnet test ..\bunit.sln -c $mode --no-restore --no-build --blame-hang --blame-hang-timeout 100s -f net5.0 --nologo
+	}
+}

From 0c73f41a5bbfa232b2d1eb5c47a3c2d5322439f0 Mon Sep 17 00:00:00 2001
From: Egil Hansen <egil@assimilated.dk>
Date: Sun, 30 Aug 2020 21:30:26 +0000
Subject: [PATCH 04/11] Fixed order of notifications from rendered fragment

---
 src/bunit.web/Rendering/RenderedFragment.cs   |  4 +--
 .../Rendering/TestRendererTest.cs             |  7 ++--
 .../BlazorE2E/ComponentRenderingTest.cs       | 10 ------
 .../EventBubblingTest.cs                      | 35 -------------------
 .../SampleComponents/SkipRazorComponent.cs    | 24 -------------
 5 files changed, 6 insertions(+), 74 deletions(-)
 delete mode 100644 tests/bunit.web.tests/EventDispatchExtensions/EventBubblingTest.cs
 delete mode 100644 tests/bunit.xunit.tests/SampleComponents/SkipRazorComponent.cs

diff --git a/src/bunit.web/Rendering/RenderedFragment.cs b/src/bunit.web/Rendering/RenderedFragment.cs
index 60df253c9..f28ea3703 100644
--- a/src/bunit.web/Rendering/RenderedFragment.cs
+++ b/src/bunit.web/Rendering/RenderedFragment.cs
@@ -129,10 +129,10 @@ void IRenderedFragmentBase.OnRender(RenderEvent renderEvent)
 				}
 			}
 
-			if (rendered)
-				OnAfterRender?.Invoke();
 			if (changed)
 				OnMarkupUpdated?.Invoke();
+			if (rendered)
+				OnAfterRender?.Invoke();
 		}
 
 		protected void UpdateMarkup(RenderTreeFrameCollection framesCollection)
diff --git a/tests/bunit.core.tests/Rendering/TestRendererTest.cs b/tests/bunit.core.tests/Rendering/TestRendererTest.cs
index 3c6518e49..8235d4d43 100644
--- a/tests/bunit.core.tests/Rendering/TestRendererTest.cs
+++ b/tests/bunit.core.tests/Rendering/TestRendererTest.cs
@@ -16,8 +16,6 @@ namespace Bunit.Rendering
 {
 	public class TestRendererTest
 	{
-		private static readonly ServiceProvider ServiceProvider = new ServiceCollection().BuildServiceProvider();
-
 		[Fact(DisplayName = "Can render component that awaits uncompleted task in OnInitializedAsync")]
 		public void Test100()
 		{
@@ -40,7 +38,10 @@ public void Test101()
 				parameters.Add(p => p.EitherOr, Task.Delay(1))
 			);
 
-			cut.Find("h1").TextContent.ShouldBe("FIRST");
+
+			var h1 = cut.Find("h1");
+
+			cut.WaitForAssertion(() => h1.TextContent.ShouldBe("SECOND"));
 		}
 
 		[Fact(DisplayName = "Can render component that awaits completed task in OnInitializedAsync")]
diff --git a/tests/bunit.web.tests/BlazorE2E/ComponentRenderingTest.cs b/tests/bunit.web.tests/BlazorE2E/ComponentRenderingTest.cs
index c1f901d04..3d0cebe95 100644
--- a/tests/bunit.web.tests/BlazorE2E/ComponentRenderingTest.cs
+++ b/tests/bunit.web.tests/BlazorE2E/ComponentRenderingTest.cs
@@ -99,16 +99,6 @@ public void CanTriggerKeyPressEvents()
 			);
 		}
 
-		[Fact(DisplayName = "After KeyPress event is triggered, <input value=''> contains keys passed to KeyPress", Skip = "Issue #46 - https://github.com/egil/razor-components-testing-library/issues/46")]
-		public void Test001()
-		{
-			var cut = RenderComponent<KeyPressEventComponent>();
-
-			cut.Find("input").KeyPress("abc");
-
-			cut.Find("input").GetAttribute("value").ShouldBe("abc");
-		}
-
 		[Fact]
 		public void CanAddAndRemoveEventHandlersDynamically()
 		{
diff --git a/tests/bunit.web.tests/EventDispatchExtensions/EventBubblingTest.cs b/tests/bunit.web.tests/EventDispatchExtensions/EventBubblingTest.cs
deleted file mode 100644
index 3c8ff5818..000000000
--- a/tests/bunit.web.tests/EventDispatchExtensions/EventBubblingTest.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-using Bunit.TestAssets.SampleComponents;
-
-using Shouldly;
-
-using Xunit;
-
-namespace Bunit.EventDispatchExtensions
-{
-	public class EventBubblingTest : TestContext
-	{
-		[Fact(DisplayName = "When clicking on an element with an event handler, " +
-							"event handlers higher up the DOM tree is also triggered", Skip = "fix with #119")]
-		public void Test001()
-		{
-			var cut = RenderComponent<ClickEventBubbling>();
-
-			cut.Find("span").Click();
-
-			cut.Instance.SpanClickCount.ShouldBe(1);
-			cut.Instance.HeaderClickCount.ShouldBe(1);
-		}
-
-		[Fact(DisplayName = "When clicking on an element without an event handler attached, " +
-							"event handlers higher up the DOM tree is triggered", Skip = "fix with #119")]
-		public void Test002()
-		{
-			var cut = RenderComponent<ClickEventBubbling>();
-
-			cut.Find("button").Click();
-
-			cut.Instance.SpanClickCount.ShouldBe(0);
-			cut.Instance.HeaderClickCount.ShouldBe(1);
-		}
-	}
-}
diff --git a/tests/bunit.xunit.tests/SampleComponents/SkipRazorComponent.cs b/tests/bunit.xunit.tests/SampleComponents/SkipRazorComponent.cs
deleted file mode 100644
index 50f6398a8..000000000
--- a/tests/bunit.xunit.tests/SampleComponents/SkipRazorComponent.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using System;
-
-using Microsoft.AspNetCore.Components;
-using Microsoft.AspNetCore.Components.Rendering;
-
-namespace Bunit.SampleComponents
-{
-	public class SkipRazorComponent : TestComponentBase
-	{
-		protected override void BuildRenderTree(RenderTreeBuilder builder)
-		{
-			builder.OpenComponent<Fixture>(10);
-			builder.AddAttribute(11, nameof(Fixture.Description), "FIXTURE SKIPPED");
-			builder.AddAttribute(11, nameof(Fixture.Skip), "SKIP ME");
-			builder.AddAttribute(12, nameof(Fixture.ChildContent), (RenderFragment)Content);
-			builder.AddAttribute(13, nameof(Fixture.Test), (Action<Fixture>)TestMethod);
-			builder.CloseComponent();
-		}
-
-		private void TestMethod(Fixture fixture) { }
-
-		private void Content(RenderTreeBuilder builder) { }
-	}
-}

From 4472ea9ac94b80edf31851925081283992be9bcf Mon Sep 17 00:00:00 2001
From: Egil Hansen <egil@assimilated.dk>
Date: Mon, 31 Aug 2020 22:38:25 +0000
Subject: [PATCH 05/11] Added code comments to refactored code, simplified
 TestRenderer

---
 src/Directory.Build.props                    |   4 +-
 src/bunit.core/IRenderedFragmentBase.cs      |  13 +
 src/bunit.core/Rendering/ITestRenderer.cs    |  21 ++
 src/bunit.core/Rendering/RenderEvent.cs      |  29 ++-
 src/bunit.core/Rendering/TestRenderer.cs     | 261 ++++++++++---------
 src/bunit.web/IRenderedFragment.cs           |   3 +
 src/bunit.web/Rendering/Internal/Htmlizer.cs |  12 +-
 src/bunit.web/Rendering/RenderedFragment.cs  |   4 +-
 8 files changed, 208 insertions(+), 139 deletions(-)

diff --git a/src/Directory.Build.props b/src/Directory.Build.props
index c56d53a84..dc1a9ad8e 100644
--- a/src/Directory.Build.props
+++ b/src/Directory.Build.props
@@ -23,9 +23,9 @@
 		<Deterministic>true</Deterministic>
 	</PropertyGroup>
 
-	<!--<PropertyGroup Condition="'$(Configuration)' == 'Release' AND $(MSBuildProjectName)!='bunit.template' AND $(MSBuildProjectName)!='bunit'">
+	<PropertyGroup Condition="'$(Configuration)' == 'Release' AND $(MSBuildProjectName)!='bunit.template' AND $(MSBuildProjectName)!='bunit'">
 		<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-	</PropertyGroup>-->
+	</PropertyGroup>
 
 	<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.1' AND $(MSBuildProjectName)!='bunit.template' AND $(MSBuildProjectName)!='bunit'">
 		<PackageReference Include="Microsoft.AspNetCore.Components.Authorization" Version="3.1.1" />
diff --git a/src/bunit.core/IRenderedFragmentBase.cs b/src/bunit.core/IRenderedFragmentBase.cs
index 5bfd52820..e0d263040 100644
--- a/src/bunit.core/IRenderedFragmentBase.cs
+++ b/src/bunit.core/IRenderedFragmentBase.cs
@@ -6,12 +6,25 @@ namespace Bunit
 {
 	public interface IRenderedFragmentBase : IDisposable
 	{
+		/// <summary>
+		/// Gets the total number times the fragment has been through its render life-cycle.
+		/// </summary>
 		int RenderCount { get; }
 
+		/// <summary>
+		/// Gets whether the rendered component or fragment has been disposed by the <see cref="ITestRenderer"/>.
+		/// </summary>
 		bool IsDisposed { get; }
 
+		/// <summary>
+		/// Gets the id of the rendered component or fragment.
+		/// </summary>
 		int ComponentId { get; }
 
+		/// <summary>
+		/// Called by the owning <see cref="ITestRenderer"/> when it finishes a render.
+		/// </summary>
+		/// <param name="renderEvent">A <see cref="RenderEvent"/> that represents a render.</param>
 		void OnRender(RenderEvent renderEvent);
 
 		/// <summary>
diff --git a/src/bunit.core/Rendering/ITestRenderer.cs b/src/bunit.core/Rendering/ITestRenderer.cs
index e78ca2769..1a8d75713 100644
--- a/src/bunit.core/Rendering/ITestRenderer.cs
+++ b/src/bunit.core/Rendering/ITestRenderer.cs
@@ -27,14 +27,35 @@ public interface ITestRenderer
 		/// <returns>A <see cref="Task"/> which will complete once all asynchronous processing related to the event has completed.</returns>
 		Task DispatchEventAsync(ulong eventHandlerId, EventFieldInfo fieldInfo, EventArgs eventArgs);
 
+		/// <summary>
+		/// Renders the <paramref name="renderFragment"/>.
+		/// </summary>
+		/// <param name="renderFragment">The <see cref="Microsoft.AspNetCore.Components.RenderFragment"/> to render.</param>
+		/// <returns>A <see cref="IRenderedFragmentBase"/> that provides access to the rendered <paramref name="renderFragment"/>.</returns>
 		IRenderedFragmentBase RenderFragment(RenderFragment renderFragment);
 
+		/// <summary>
+		/// Renders a <typeparamref name="TComponent"/> with the parameters <paramref name="componentParameters"/> passed to it.
+		/// </summary>
+		/// <typeparam name = "TComponent" > The type of component to render.</typeparam>
+		/// <param name="componentParameters">The parameters to pass to the component.</param>
+		/// <returns>A <see cref="IRenderedComponentBase{TComponent}"/> that provides access to the rendered component.</returns>
 		IRenderedComponentBase<TComponent> RenderComponent<TComponent>(IEnumerable<ComponentParameter> componentParameters)
 			where TComponent : IComponent;
 
+		/// <summary>
+		/// Performs a depth-first search for the first <typeparamref name="TComponent"/> child component of the <paramref name="parentComponent"/>.
+		/// </summary>
+		/// <typeparam name="TComponent">Type of component to find.</typeparam>
+		/// <param name="parentComponent">Parent component to search.</param>
 		IRenderedComponentBase<TComponent> FindComponent<TComponent>(IRenderedFragmentBase parentComponent)
 			where TComponent : IComponent;
 
+		/// <summary>
+		/// Performs a depth-first search for all <typeparamref name="TComponent"/> child components of the <paramref name="parentComponent"/>.
+		/// </summary>
+		/// <typeparam name="TComponent">Type of components to find.</typeparam>
+		/// <param name="parentComponent">Parent component to search.</param>
 		IReadOnlyList<IRenderedComponentBase<TComponent>> FindComponents<TComponent>(IRenderedFragmentBase parentComponent)
 			where TComponent : IComponent;
 	}
diff --git a/src/bunit.core/Rendering/RenderEvent.cs b/src/bunit.core/Rendering/RenderEvent.cs
index a743a5e9d..8e7fb8798 100644
--- a/src/bunit.core/Rendering/RenderEvent.cs
+++ b/src/bunit.core/Rendering/RenderEvent.cs
@@ -6,18 +6,35 @@
 
 namespace Bunit.Rendering
 {
+	/// <summary>
+	/// Represents an render event from a <see cref="ITestRenderer"/>.
+	/// </summary>
 	public sealed class RenderEvent
 	{
 		private readonly RenderBatch _renderBatch;
 
+		/// <summary>
+		/// A collection of <see cref="ArrayRange{RenderTreeFrame}"/>, accessible via the ID
+		/// of the component they are created by.
+		/// </summary>
 		public RenderTreeFrameCollection Frames { get; }
 
+		/// <summary>
+		/// Creates an instance of the <see cref="RenderEvent"/> type.
+		/// </summary>
+		/// <param name="renderBatch">The <see cref="RenderBatch"/> update from the render event.</param>
+		/// <param name="frames">The <see cref="RenderTreeFrameCollection"/> from the current render.</param>
 		internal RenderEvent(RenderBatch renderBatch, RenderTreeFrameCollection frames)
 		{
 			_renderBatch = renderBatch;
 			Frames = frames;
 		}
 
+		/// <summary>
+		/// Gets the render status for a <paramref name="renderedComponent"/>.
+		/// </summary>
+		/// <param name="renderedComponent">The <paramref name="renderedComponent"/> to get the status for.</param>
+		/// <returns>A tuple of statuses indicating whether the rendered component rendered during the render cycle, if it changed or if it was disposed.</returns>
 		public (bool rendered, bool changed, bool disposed) GetRenderStatus(IRenderedFragmentBase renderedComponent)
 		{
 			if (renderedComponent is null)
@@ -46,10 +63,20 @@ private bool DidComponentDispose(IRenderedFragmentBase renderedComponent)
 			return false;
 		}
 
+		/// <summary>
+		/// This method determines if the <paramref name="renderedComponent"/> or any of the
+		/// components underneath it in the render tree rendered and whether they they changed
+		/// their render tree during render.
+		///
+		/// It does this by getting the status from the <paramref name="renderedComponent"/>,
+		/// then from all its children, using a recursive pattern, where the internal methods
+		/// GetStatus and GetStatusFromChildren call each other until there are no more children,
+		/// or both a render and a change is found.
+		/// </summary>
 		private (bool rendered, bool hasChanges) GetRenderAndChangeStatus(IRenderedFragmentBase renderedComponent)
 		{
 			var result = (rendered: false, hasChanges: false);
-
+	
 			GetStatus(renderedComponent.ComponentId);
 
 			return result;
diff --git a/src/bunit.core/Rendering/TestRenderer.cs b/src/bunit.core/Rendering/TestRenderer.cs
index a1399e422..55d387f60 100644
--- a/src/bunit.core/Rendering/TestRenderer.cs
+++ b/src/bunit.core/Rendering/TestRenderer.cs
@@ -13,7 +13,19 @@
 
 namespace Bunit.Rendering
 {
-	public sealed class TestRenderer : Renderer, ITestRenderer
+	public partial class TestRenderer
+	{
+		private void LogUnhandledException(Exception unhandled)
+		{
+			var evt = new EventId(3, nameof(AssertNoUnhandledExceptions));
+			_logger.LogError(evt, unhandled, $"An unhandled exception happened during rendering: {unhandled.Message}{Environment.NewLine}{unhandled.StackTrace}");
+		}
+	}
+
+	/// <summary>
+	/// Represents a bUnit <see cref="ITestRenderer"/> used to render Blazor components and fragments during bUnit tests.
+	/// </summary>
+	public partial class TestRenderer : Renderer, ITestRenderer
 	{
 		private readonly object _renderTreeAccessLock = new object();
 		private readonly ILogger _logger;
@@ -21,164 +33,71 @@ public sealed class TestRenderer : Renderer, ITestRenderer
 		private Exception? _unhandledException;
 		private readonly Dictionary<int, IRenderedFragmentBase> _renderedComponents = new Dictionary<int, IRenderedFragmentBase>();
 
+		/// <inheritdoc/>
 		public override Dispatcher Dispatcher { get; } = Dispatcher.CreateDefault();
 
+		/// <summary>
+		/// Creates an instance of the <see cref="TestRenderer"/>.
+		/// </summary>
 		public TestRenderer(IRenderedComponentActivator activator, IServiceProvider services, ILoggerFactory loggerFactory) : base(services, loggerFactory)
 		{
 			_logger = loggerFactory.CreateLogger<TestRenderer>();
 			_activator = activator;
 		}
 
+		/// <inheritdoc/>
 		public IRenderedFragmentBase RenderFragment(RenderFragment renderFragment)
 		{
-			IRenderedFragmentBase renderedComponent = default!;
-			var task = Dispatcher.InvokeAsync(() =>
-			{
-				var root = new WrapperComponent(renderFragment);
-				var rootComponentId = AssignRootComponentId(root);
-				renderedComponent = _activator.CreateRenderedComponent(rootComponentId);
-				_renderedComponents.Add(rootComponentId, renderedComponent);
-				root.Render();
-			});
-
-			Debug.Assert(task.IsCompleted, "The render task did not complete as expected");
-			AssertNoUnhandledExceptions();
-
-			return renderedComponent!;
+			return Render(renderFragment, id => _activator.CreateRenderedComponent(id));
 		}
 
+		/// <inheritdoc/>
 		public IRenderedComponentBase<TComponent> RenderComponent<TComponent>(IEnumerable<ComponentParameter> componentParameters)
 			where TComponent : IComponent
 		{
-			IRenderedComponentBase<TComponent> renderedComponent = default!;
-			var task = Dispatcher.InvokeAsync(() =>
-			{
-				var root = new WrapperComponent(componentParameters.ToComponentRenderFragment<TComponent>());
-				var rootComponentId = AssignRootComponentId(root);
-				renderedComponent = _activator.CreateRenderedComponent<TComponent>(rootComponentId);
-				_renderedComponents.Add(rootComponentId, renderedComponent);
-				root.Render();
-			});
-
-			Debug.Assert(task.IsCompleted, "The render task did not complete as expected");
-			AssertNoUnhandledExceptions();
-
-			return renderedComponent!;
+			var parameters = componentParameters.ToComponentRenderFragment<TComponent>();
+			return Render(parameters, id => _activator.CreateRenderedComponent<TComponent>(id));
 		}
 
-		public IRenderedComponentBase<TComponent> FindComponent<TComponent>(IRenderedFragmentBase parentComponent) where TComponent : IComponent
+		/// <inheritdoc/>
+		public new Task DispatchEventAsync(ulong eventHandlerId, EventFieldInfo fieldInfo, EventArgs eventArgs)
 		{
-			if (parentComponent is null)
-				throw new ArgumentNullException(nameof(parentComponent));
-
-			var framesCollection = new RenderTreeFrameCollection();
-
-			lock (_renderTreeAccessLock)
-			{
-				if (TryFindComponent(parentComponent.ComponentId, out var id, out var component))
-				{
-					LoadRenderTreeFrames(id, framesCollection);
-					var rc = _activator.CreateRenderedComponent(id, component, framesCollection);
-					_renderedComponents.Add(rc.ComponentId, rc);
-					return rc;
-				}
-				else
-				{
-					throw new ComponentNotFoundException(typeof(TComponent));
-				}
-			}
-
-			bool TryFindComponent(int parentComponentId, out int componentId, out TComponent component)
-			{
-				var result = false;
-				componentId = -1;
-				component = default!;
-
-				var frames = LoadAndGetRenderTreeFrame(framesCollection, parentComponentId);
+			if (fieldInfo is null)
+				throw new ArgumentNullException(nameof(fieldInfo));
 
-				for (var i = 0; i < frames.Count; i++)
-				{
-					ref var frame = ref frames.Array[i];
-					if (frame.FrameType == RenderTreeFrameType.Component)
-					{
-						if (frame.Component is TComponent c)
-						{
-							componentId = frame.ComponentId;
-							component = c;
-							result = true;
-							break;
-						}
+			var result = Dispatcher.InvokeAsync(() => base.DispatchEventAsync(eventHandlerId, fieldInfo, eventArgs));
 
-						if (TryFindComponent(frame.ComponentId, out componentId, out component))
-						{
-							result = true;
-							break;
-						}
-					}
-				}
+			AssertNoUnhandledExceptions();
 
-				return result;
-			}
+			return result;
 		}
 
-		public IReadOnlyList<IRenderedComponentBase<TComponent>> FindComponents<TComponent>(IRenderedFragmentBase parentComponent)
-			where TComponent : IComponent
+		/// <inheritdoc/>
+		public IRenderedComponentBase<TComponent> FindComponent<TComponent>(IRenderedFragmentBase parentComponent) where TComponent : IComponent
 		{
-			if (parentComponent is null)
-				throw new ArgumentNullException(nameof(parentComponent));
-
-			var result = new List<IRenderedComponentBase<TComponent>>();
-			var framesCollection = new RenderTreeFrameCollection();
-
-			lock (_renderTreeAccessLock)
+			var foundComponents = FindComponents<TComponent>(parentComponent, 1);
+			if (foundComponents.Count == 1)
 			{
-				FindComponentsInternal(parentComponent.ComponentId);
-				foreach (var rc in result)
-				{
-					_renderedComponents.Add(rc.ComponentId, rc);
-				}
+				return foundComponents[0];
 			}
-
-			return result;
-
-			void FindComponentsInternal(int componentId)
+			else
 			{
-				var frames = LoadAndGetRenderTreeFrame(framesCollection, componentId);
-
-				for (var i = 0; i < frames.Count; i++)
-				{
-					ref var frame = ref frames.Array[i];
-					if (frame.FrameType == RenderTreeFrameType.Component)
-					{
-						if (frame.Component is TComponent component)
-						{
-							var id = frame.ComponentId;
-							LoadRenderTreeFrames(id, framesCollection);
-							var rc = _activator.CreateRenderedComponent(id, component, framesCollection);
-							result.Add(rc);
-						}
-
-						FindComponentsInternal(frame.ComponentId);
-					}
-				}
+				throw new ComponentNotFoundException(typeof(TComponent));
 			}
 		}
 
-		public new Task DispatchEventAsync(ulong eventHandlerId, EventFieldInfo fieldInfo, EventArgs eventArgs)
-		{
-			if (fieldInfo is null)
-				throw new ArgumentNullException(nameof(fieldInfo));
-
-			var result = Dispatcher.InvokeAsync(() => base.DispatchEventAsync(eventHandlerId, fieldInfo, eventArgs));
-
-			AssertNoUnhandledExceptions();
-
-			return result;
-		}
+		/// <inheritdoc/>
+		public IReadOnlyList<IRenderedComponentBase<TComponent>> FindComponents<TComponent>(IRenderedFragmentBase parentComponent) where TComponent : IComponent
+			=> FindComponents<TComponent>(parentComponent, int.MaxValue);
 
 		/// <inheritdoc/>
 		protected override void ProcessPendingRender()
 		{
+			// the lock is in place to avoid a race condition between
+			// the dispatchers thread and the test frameworks thread,
+			// where one will read the current render tree (find components)
+			// while the other thread (the renderer) updates the
+			// render tree.
 			lock (_renderTreeAccessLock)
 			{
 				base.ProcessPendingRender();
@@ -205,6 +124,7 @@ protected override Task UpdateDisplayAsync(in RenderBatch renderBatch)
 				}
 			}
 
+			// notify each rendered component about the render
 			foreach (var (key, rc) in _renderedComponents.ToArray())
 			{
 				LoadRenderTreeFrames(rc.ComponentId, renderEvent.Frames);
@@ -236,9 +156,86 @@ protected override void Dispose(bool disposing)
 			base.Dispose(disposing);
 		}
 
+		private TResult Render<TResult>(RenderFragment renderFragment, Func<int, TResult> activator)
+			where TResult : IRenderedFragmentBase
+		{
+			TResult renderedComponent = default!;
+			var task = Dispatcher.InvokeAsync(() =>
+			{
+				var root = new WrapperComponent(renderFragment);
+				var rootComponentId = AssignRootComponentId(root);
+				renderedComponent = activator(rootComponentId);
+				_renderedComponents.Add(rootComponentId, renderedComponent);
+				root.Render();
+			});
+
+			Debug.Assert(task.IsCompleted, "The render task did not complete as expected");
+			AssertNoUnhandledExceptions();
+
+			return renderedComponent!;
+		}
+
+		private IReadOnlyList<IRenderedComponentBase<TComponent>> FindComponents<TComponent>(IRenderedFragmentBase parentComponent, int resultLimit)
+			where TComponent : IComponent
+		{
+			if (parentComponent is null)
+				throw new ArgumentNullException(nameof(parentComponent));
+
+			var result = new List<IRenderedComponentBase<TComponent>>();
+			var framesCollection = new RenderTreeFrameCollection();
+
+			// the lock is in place to avoid a race condition between
+			// the dispatchers thread and the test frameworks thread,
+			// where one will read the current render tree (this method)
+			// while the other thread (the renderer) updates the
+			// render tree.
+			lock (_renderTreeAccessLock)
+			{
+				FindComponentsInternal(parentComponent.ComponentId);
+				foreach (var rc in result)
+				{
+					_renderedComponents.Add(rc.ComponentId, rc);
+				}
+			}
+
+			return result;
+
+			void FindComponentsInternal(int componentId)
+			{
+				var frames = GetOrLoadRenderTreeFrame(framesCollection, componentId);
+
+				for (var i = 0; i < frames.Count; i++)
+				{
+					ref var frame = ref frames.Array[i];
+					if (frame.FrameType == RenderTreeFrameType.Component)
+					{
+						if (frame.Component is TComponent component)
+						{
+							var id = frame.ComponentId;
+							LoadRenderTreeFrames(id, framesCollection);
+							var rc = _activator.CreateRenderedComponent(id, component, framesCollection);
+							result.Add(rc);
+
+							if (result.Count == resultLimit)
+								return;
+						}
+
+						FindComponentsInternal(frame.ComponentId);
+
+						if (result.Count == resultLimit)
+							return;
+					}
+				}
+			}
+		}
+
+		/// <summary>
+		/// Populates the <paramref name="framesCollection"/> with <see cref="ArrayRange{RenderTreeFrame}"/>
+		/// starting with the one that belongs to the component with ID <paramref name="componentId"/>.
+		/// </summary>
 		private void LoadRenderTreeFrames(int componentId, RenderTreeFrameCollection framesCollection)
 		{
-			var frames = LoadAndGetRenderTreeFrame(framesCollection, componentId);
+			var frames = GetOrLoadRenderTreeFrame(framesCollection, componentId);
 
 			for (var i = 0; i < frames.Count; i++)
 			{
@@ -250,11 +247,16 @@ private void LoadRenderTreeFrames(int componentId, RenderTreeFrameCollection fra
 			}
 		}
 
-		private ArrayRange<RenderTreeFrame> LoadAndGetRenderTreeFrame(RenderTreeFrameCollection framesCollection, int componentId)
+		/// <summary>
+		/// Gets the <see cref="ArrayRange{RenderTreeFrame}"/> from the <paramref name="framesCollection"/>.
+		/// If the <paramref name="framesCollection"/> does not contain the frames, they are loaded into it first.
+		/// </summary>
+		private ArrayRange<RenderTreeFrame> GetOrLoadRenderTreeFrame(RenderTreeFrameCollection framesCollection, int componentId)
 		{
 			if (!framesCollection.Contains(componentId))
 			{
-				framesCollection.Add(componentId, GetCurrentRenderTreeFrames(componentId));
+				var frames = GetCurrentRenderTreeFrames(componentId);
+				framesCollection.Add(componentId, frames);
 			}
 
 			return framesCollection[componentId];
@@ -265,8 +267,7 @@ private void AssertNoUnhandledExceptions()
 			if (_unhandledException is { } unhandled)
 			{
 				_unhandledException = null;
-				var evt = new EventId(3, nameof(AssertNoUnhandledExceptions));
-				_logger.LogError(evt, unhandled, $"An unhandled exception happened during rendering: {unhandled.Message}{Environment.NewLine}{unhandled.StackTrace}");
+				LogUnhandledException(unhandled);
 				ExceptionDispatchInfo.Capture(unhandled).Throw();
 			}
 		}
diff --git a/src/bunit.web/IRenderedFragment.cs b/src/bunit.web/IRenderedFragment.cs
index e792cc230..dc3ab85aa 100644
--- a/src/bunit.web/IRenderedFragment.cs
+++ b/src/bunit.web/IRenderedFragment.cs
@@ -13,6 +13,9 @@ namespace Bunit
 	/// </summary>
 	public interface IRenderedFragment : IRenderedFragmentBase
 	{
+		/// <summary>
+		/// An event that is raised after the markup of the <see cref="IRenderedFragmentBase"/> is updated.
+		/// </summary>
 		event Action OnMarkupUpdated;
 
 		/// <summary>
diff --git a/src/bunit.web/Rendering/Internal/Htmlizer.cs b/src/bunit.web/Rendering/Internal/Htmlizer.cs
index e5ddc6eb3..275ae61b8 100644
--- a/src/bunit.web/Rendering/Internal/Htmlizer.cs
+++ b/src/bunit.web/Rendering/Internal/Htmlizer.cs
@@ -15,7 +15,6 @@ namespace Bunit
 	/// This file is based on
 	/// https://source.dot.net/#Microsoft.AspNetCore.Mvc.ViewFeatures/RazorComponents/HtmlRenderer.cs
 	/// </summary>
-	[SuppressMessage("Usage", "BL0006:Do not use RenderTree types", Justification = "<Pending>")]
 	public static class Htmlizer
 	{
 		private static readonly HtmlEncoder HtmlEncoder = HtmlEncoder.Default;
@@ -27,12 +26,15 @@ public static class Htmlizer
 
 		private const string BLAZOR_INTERNAL_ATTR_PREFIX = "__internal_";
 		private const string BLAZOR_CSS_SCOPE_ATTR_PREFIX = "b-";
-		public const string BLAZOR_ATTR_PREFIX = "blazor:";
-		public const string ELEMENT_REFERENCE_ATTR_NAME = BLAZOR_ATTR_PREFIX + "elementreference";
+		internal const string BLAZOR_ATTR_PREFIX = "blazor:";
+		internal const string ELEMENT_REFERENCE_ATTR_NAME = BLAZOR_ATTR_PREFIX + "elementreference";
 
 		public static bool IsBlazorAttribute(string attributeName)
-			=> attributeName.StartsWith(BLAZOR_ATTR_PREFIX, StringComparison.Ordinal) ||
-			   attributeName.StartsWith(BLAZOR_CSS_SCOPE_ATTR_PREFIX, StringComparison.Ordinal);
+		{
+			if (attributeName is null) throw new ArgumentNullException(nameof(attributeName));
+			return attributeName.StartsWith(BLAZOR_ATTR_PREFIX, StringComparison.Ordinal) ||
+						  attributeName.StartsWith(BLAZOR_CSS_SCOPE_ATTR_PREFIX, StringComparison.Ordinal);
+		}
 
 		public static string ToBlazorAttribute(string attributeName)
 		{
diff --git a/src/bunit.web/Rendering/RenderedFragment.cs b/src/bunit.web/Rendering/RenderedFragment.cs
index f28ea3703..9e6c6c686 100644
--- a/src/bunit.web/Rendering/RenderedFragment.cs
+++ b/src/bunit.web/Rendering/RenderedFragment.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -17,6 +18,7 @@ namespace Bunit.Rendering
 	internal class RenderedFragment : IRenderedFragment
 	{
 		private readonly object _markupAccessLock = new object();
+		[SuppressMessage("Usage", "CA2213:Disposable fields should be disposed", Justification = "Instance is owned by the service provider and should not be disposed here.")]
 		private readonly HtmlParser _htmlParser;
 		private string _markup = string.Empty;
 		private string? _snapshotMarkup;
@@ -28,7 +30,7 @@ internal class RenderedFragment : IRenderedFragment
 		/// <summary>
 		/// Gets the first rendered markup.
 		/// </summary>
-		protected string FirstRenderMarkup { get; private set; }
+		protected string FirstRenderMarkup { get; private set; } = string.Empty;
 
 		public event Action? OnAfterRender;
 		public event Action? OnMarkupUpdated;

From 8f485276d28a53db9ba7dc4f1f914412a5baba80 Mon Sep 17 00:00:00 2001
From: Egil Hansen <egil@assimilated.dk>
Date: Mon, 31 Aug 2020 23:08:18 +0000
Subject: [PATCH 06/11] Updated code docs, small refactors to code

---
 src/bunit.core/IRenderedFragmentBase.cs       |  4 ++
 .../Rendering/IRenderedComponentActivator.cs  | 13 +++++
 .../Rendering/RenderTreeFrameCollection.cs    | 48 ++++++-------------
 src/bunit.core/Rendering/TestRenderer.cs      | 12 +----
 src/bunit.core/Rendering/TestRenderer.log.cs  | 14 ++++++
 src/bunit.web/Rendering/Internal/Htmlizer.cs  |  2 +-
 src/bunit.web/Rendering/RenderedComponent.cs  | 41 ++++++++++++++--
 .../Rendering/RenderedComponentActivator.cs   |  6 +++
 src/bunit.web/Rendering/RenderedFragment.cs   | 39 ++++++++++++++-
 9 files changed, 131 insertions(+), 48 deletions(-)
 create mode 100644 src/bunit.core/Rendering/TestRenderer.log.cs

diff --git a/src/bunit.core/IRenderedFragmentBase.cs b/src/bunit.core/IRenderedFragmentBase.cs
index e0d263040..3cfd4f733 100644
--- a/src/bunit.core/IRenderedFragmentBase.cs
+++ b/src/bunit.core/IRenderedFragmentBase.cs
@@ -1,9 +1,13 @@
 using System;
 
 using Bunit.Rendering;
+using Microsoft.AspNetCore.Components;
 
 namespace Bunit
 {
+	/// <summary>
+	/// Represents a rendered <see cref="RenderFragment"/>.
+	/// </summary>
 	public interface IRenderedFragmentBase : IDisposable
 	{
 		/// <summary>
diff --git a/src/bunit.core/Rendering/IRenderedComponentActivator.cs b/src/bunit.core/Rendering/IRenderedComponentActivator.cs
index 3042c93dc..c0c776a26 100644
--- a/src/bunit.core/Rendering/IRenderedComponentActivator.cs
+++ b/src/bunit.core/Rendering/IRenderedComponentActivator.cs
@@ -3,13 +3,26 @@
 
 namespace Bunit.Rendering
 {
+	/// <summary>
+	/// Represents an activator for <see cref="IRenderedFragmentBase"/> and <see cref="IRenderedComponentBase{TComponent}"/> types.
+	/// </summary>
 	public interface IRenderedComponentActivator
 	{
+		/// <summary>
+		/// Creates an <see cref="IRenderedFragmentBase"/> with the specified <paramref name="componentId"/>.
+		/// </summary>
 		IRenderedFragmentBase CreateRenderedComponent(int componentId);
 
+		/// <summary>
+		/// Creates an <see cref="IRenderedComponentBase{TComponent}"/> with the specified <paramref name="componentId"/>.
+		/// </summary>
 		IRenderedComponentBase<TComponent> CreateRenderedComponent<TComponent>(int componentId)
 			where TComponent : IComponent;
 
+		/// <summary>
+		/// Creates an <see cref="IRenderedComponentBase{TComponent}"/> with the specified <paramref name="componentId"/>,
+		/// <paramref name="component"/>, and <paramref name="componentFrames"/>.
+		/// </summary>
 		IRenderedComponentBase<TComponent> CreateRenderedComponent<TComponent>(int componentId, TComponent component, RenderTreeFrameCollection componentFrames)
 			where TComponent : IComponent;
 	}
diff --git a/src/bunit.core/Rendering/RenderTreeFrameCollection.cs b/src/bunit.core/Rendering/RenderTreeFrameCollection.cs
index 049408f08..a492460eb 100644
--- a/src/bunit.core/Rendering/RenderTreeFrameCollection.cs
+++ b/src/bunit.core/Rendering/RenderTreeFrameCollection.cs
@@ -4,48 +4,30 @@
 
 namespace Bunit.Rendering
 {
+	/// <summary>
+	/// Represents a collection of <see cref="ArrayRange{RenderTreeFrame}"/>.
+	/// </summary>
 	public sealed class RenderTreeFrameCollection
 	{
-		private Dictionary<int, ArrayRange<RenderTreeFrame>> _currentRenderTree = new Dictionary<int, ArrayRange<RenderTreeFrame>>();
+		private readonly Dictionary<int, ArrayRange<RenderTreeFrame>> _currentRenderTree = new Dictionary<int, ArrayRange<RenderTreeFrame>>();
 
+		/// <summary>
+		/// Gets the <see cref="ArrayRange{RenderTreeFrame}"/> associated with the <paramref name="componentId"/>.
+		/// </summary>
+		/// <param name="componentId"></param>
+		/// <returns></returns>
 		public ArrayRange<RenderTreeFrame> this[int componentId] => _currentRenderTree[componentId];
 
+		/// <summary>
+		/// Creates an instance of the <see cref="RenderTreeFrameCollection"/>,
+		/// </summary>
 		internal RenderTreeFrameCollection() { }
 
+		/// <summary>
+		/// Checks whether the collection contains a <see cref="ArrayRange{RenderTreeFrame}"/> for the <paramref name="componentId"/>.
+		/// </summary>
 		public bool Contains(int componentId) => _currentRenderTree.ContainsKey(componentId);
 
 		internal void Add(int componentId, ArrayRange<RenderTreeFrame> frames) => _currentRenderTree.Add(componentId, frames);
-
-		public bool TryFindComponent<TComponent>(int parentComponentId, out int componentId, out TComponent component)
-		{
-			var result = false;
-			componentId = -1;
-			component = default!;
-
-			var frames = _currentRenderTree[parentComponentId];
-
-			for (var i = 0; i < frames.Count; i++)
-			{
-				ref var frame = ref frames.Array[i];
-				if (frame.FrameType == RenderTreeFrameType.Component)
-				{
-					if (frame.Component is TComponent c)
-					{
-						componentId = frame.ComponentId;
-						component = c;
-						result = true;
-						break;
-					}
-
-					if (TryFindComponent(frame.ComponentId, out componentId, out component))
-					{
-						result = true;
-						break;
-					}
-				}
-			}
-
-			return result;
-		}
 	}
 }
diff --git a/src/bunit.core/Rendering/TestRenderer.cs b/src/bunit.core/Rendering/TestRenderer.cs
index 55d387f60..59c1380f1 100644
--- a/src/bunit.core/Rendering/TestRenderer.cs
+++ b/src/bunit.core/Rendering/TestRenderer.cs
@@ -12,16 +12,7 @@
 using Microsoft.Extensions.Logging;
 
 namespace Bunit.Rendering
-{
-	public partial class TestRenderer
-	{
-		private void LogUnhandledException(Exception unhandled)
-		{
-			var evt = new EventId(3, nameof(AssertNoUnhandledExceptions));
-			_logger.LogError(evt, unhandled, $"An unhandled exception happened during rendering: {unhandled.Message}{Environment.NewLine}{unhandled.StackTrace}");
-		}
-	}
-
+{	
 	/// <summary>
 	/// Represents a bUnit <see cref="ITestRenderer"/> used to render Blazor components and fragments during bUnit tests.
 	/// </summary>
@@ -128,6 +119,7 @@ protected override Task UpdateDisplayAsync(in RenderBatch renderBatch)
 			foreach (var (key, rc) in _renderedComponents.ToArray())
 			{
 				LoadRenderTreeFrames(rc.ComponentId, renderEvent.Frames);
+				
 				rc.OnRender(renderEvent);
 
 				// RC can replace the instance of the component is bound
diff --git a/src/bunit.core/Rendering/TestRenderer.log.cs b/src/bunit.core/Rendering/TestRenderer.log.cs
new file mode 100644
index 000000000..8abe3c672
--- /dev/null
+++ b/src/bunit.core/Rendering/TestRenderer.log.cs
@@ -0,0 +1,14 @@
+using System;
+using Microsoft.Extensions.Logging;
+
+namespace Bunit.Rendering
+{
+	public partial class TestRenderer
+	{
+		private void LogUnhandledException(Exception unhandled)
+		{
+			var evt = new EventId(3, nameof(AssertNoUnhandledExceptions));
+			_logger.LogError(evt, unhandled, $"An unhandled exception happened during rendering: {unhandled.Message}{Environment.NewLine}{unhandled.StackTrace}");
+		}
+	}
+}
diff --git a/src/bunit.web/Rendering/Internal/Htmlizer.cs b/src/bunit.web/Rendering/Internal/Htmlizer.cs
index 275ae61b8..6f6fb0917 100644
--- a/src/bunit.web/Rendering/Internal/Htmlizer.cs
+++ b/src/bunit.web/Rendering/Internal/Htmlizer.cs
@@ -15,7 +15,7 @@ namespace Bunit
 	/// This file is based on
 	/// https://source.dot.net/#Microsoft.AspNetCore.Mvc.ViewFeatures/RazorComponents/HtmlRenderer.cs
 	/// </summary>
-	public static class Htmlizer
+	internal static class Htmlizer
 	{
 		private static readonly HtmlEncoder HtmlEncoder = HtmlEncoder.Default;
 
diff --git a/src/bunit.web/Rendering/RenderedComponent.cs b/src/bunit.web/Rendering/RenderedComponent.cs
index 6f5132d66..1dc553284 100644
--- a/src/bunit.web/Rendering/RenderedComponent.cs
+++ b/src/bunit.web/Rendering/RenderedComponent.cs
@@ -4,6 +4,7 @@
 using System.Threading.Tasks;
 
 using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.RenderTree;
 
 namespace Bunit.Rendering
 {
@@ -22,9 +23,9 @@ public TComponent Instance
 			}
 		}
 
-		public RenderedComponent(int componentId, IServiceProvider services) : base(componentId, services) { }
+		internal RenderedComponent(int componentId, IServiceProvider services) : base(componentId, services) { }
 
-		public RenderedComponent(int componentId, TComponent instance, RenderTreeFrameCollection componentFrames, IServiceProvider services) : base(componentId, services)
+		internal RenderedComponent(int componentId, TComponent instance, RenderTreeFrameCollection componentFrames, IServiceProvider services) : base(componentId, services)
 		{
 			_instance = instance;
 			RenderCount++;
@@ -33,6 +34,8 @@ public RenderedComponent(int componentId, TComponent instance, RenderTreeFrameCo
 
 		protected override void OnRender(RenderEvent renderEvent)
 		{
+			// checks if this is the first render, and if it is
+			// tries to find the TCompoent in the render event			
 			if (_instance is null)
 			{
 				SetComponentAndID(renderEvent);
@@ -41,7 +44,7 @@ protected override void OnRender(RenderEvent renderEvent)
 
 		private void SetComponentAndID(RenderEvent renderEvent)
 		{			
-			if (renderEvent.Frames.TryFindComponent<TComponent>(ComponentId, out var id, out var component))
+			if (TryFindComponent(renderEvent.Frames, ComponentId, out var id, out var component))
 			{
 				_instance = component;
 				ComponentId = id;
@@ -51,5 +54,37 @@ private void SetComponentAndID(RenderEvent renderEvent)
 				throw new InvalidOperationException("Component instance not found at expected position in render tree.");
 			}
 		}
+
+		private bool TryFindComponent(RenderTreeFrameCollection framesCollection, int parentComponentId, out int componentId, out TComponent component)
+		{
+			var result = false;
+			componentId = -1;
+			component = default!;
+
+			var frames = framesCollection[parentComponentId];
+
+			for (var i = 0; i < frames.Count; i++)
+			{
+				ref var frame = ref frames.Array[i];
+				if (frame.FrameType == RenderTreeFrameType.Component)
+				{
+					if (frame.Component is TComponent c)
+					{
+						componentId = frame.ComponentId;
+						component = c;
+						result = true;
+						break;
+					}
+
+					if (TryFindComponent(framesCollection, frame.ComponentId, out componentId, out component))
+					{
+						result = true;
+						break;
+					}
+				}
+			}
+
+			return result;
+		}
 	}
 }
diff --git a/src/bunit.web/Rendering/RenderedComponentActivator.cs b/src/bunit.web/Rendering/RenderedComponentActivator.cs
index a650dfc4a..d6d6580d2 100644
--- a/src/bunit.web/Rendering/RenderedComponentActivator.cs
+++ b/src/bunit.web/Rendering/RenderedComponentActivator.cs
@@ -4,10 +4,16 @@
 
 namespace Bunit.Rendering
 {
+	/// <summary>
+	/// Represents a rendered component activator for bUnit.web.
+	/// </summary>
 	public sealed class RenderedComponentActivator : IRenderedComponentActivator
 	{
 		private readonly IServiceProvider _services;
 
+		/// <summary>
+		/// Creates an instance of the activator.
+		/// </summary>
 		public RenderedComponentActivator(IServiceProvider services)
 		{
 			_services = services;
diff --git a/src/bunit.web/Rendering/RenderedFragment.cs b/src/bunit.web/Rendering/RenderedFragment.cs
index 9e6c6c686..7016f9156 100644
--- a/src/bunit.web/Rendering/RenderedFragment.cs
+++ b/src/bunit.web/Rendering/RenderedFragment.cs
@@ -15,6 +15,7 @@
 
 namespace Bunit.Rendering
 {
+	/// <inheritdoc />
 	internal class RenderedFragment : IRenderedFragment
 	{
 		private readonly object _markupAccessLock = new object();
@@ -32,27 +33,43 @@ internal class RenderedFragment : IRenderedFragment
 		/// </summary>
 		protected string FirstRenderMarkup { get; private set; } = string.Empty;
 
+		/// <inheritdoc/>
 		public event Action? OnAfterRender;
+
+		/// <inheritdoc/>
 		public event Action? OnMarkupUpdated;
 
+		/// <inheritdoc/>
 		public bool IsDisposed { get; private set; }
 
+		/// <inheritdoc/>
 		public int ComponentId { get; protected set; }
 
+		/// <inheritdoc/>
 		public string Markup
 		{
 			get
 			{
 				EnsureComponentNotDisposed();
+
+				// The lock prevents a race condition between the renderers thread
+				// and the test frameworks thread, where one might be reading the Markup
+				// while the other is updating it due to async code in a rendered component.
 				lock (_markupAccessLock)
 				{
+					// Volatile read is necessary to ensure the updated markup
+					// is available across CPU cores. Without it, the pointer to the
+					// markup string can be stored in a CPUs register and not
+					// get updated when another CPU changes the string.
 					return Volatile.Read(ref _markup);
 				}
 			}
 		}
 
+		/// <inheritdoc/>
 		public int RenderCount { get; protected set; }
 
+		/// <inheritdoc/>
 		public INodeList Nodes
 		{
 			get
@@ -70,15 +87,17 @@ public INodeList Nodes
 			}
 		}
 
+		/// <inheritdoc/>
 		public IServiceProvider Services { get; }
 
-		public RenderedFragment(int componentId, IServiceProvider service)
+		internal RenderedFragment(int componentId, IServiceProvider service)
 		{
 			ComponentId = componentId;
 			Services = service;
 			_htmlParser = Services.GetRequiredService<HtmlParser>();
 		}
 
+		/// <inheritdoc/>
 		public IReadOnlyList<IDiff> GetChangesSinceFirstRender()
 		{
 			if (_firstRenderNodes is null)
@@ -87,6 +106,7 @@ public IReadOnlyList<IDiff> GetChangesSinceFirstRender()
 			return Nodes.CompareTo(_firstRenderNodes);
 		}
 
+		/// <inheritdoc/>
 		public IReadOnlyList<IDiff> GetChangesSinceSnapshot()
 		{
 			if (_snapshotMarkup is null)
@@ -98,6 +118,7 @@ public IReadOnlyList<IDiff> GetChangesSinceSnapshot()
 			return Nodes.CompareTo(_snapshotNodes);
 		}
 
+		/// <inheritdoc/>
 		public void SaveSnapshot()
 		{
 			_snapshotNodes = null;
@@ -117,8 +138,12 @@ void IRenderedFragmentBase.OnRender(RenderEvent renderEvent)
 				return;
 			}
 
+			// The lock prevents a race condition between the renderers thread
+			// and the test frameworks thread, where one might be reading the Markup
+			// while the other is updating it due to async code in a rendered component.
 			lock (_markupAccessLock)
 			{
+
 				if (rendered)
 				{
 					OnRender(renderEvent);
@@ -131,6 +156,9 @@ void IRenderedFragmentBase.OnRender(RenderEvent renderEvent)
 				}
 			}
 
+			// The order here is important, since consumers of the events
+			// expect that markup has indeed changed when OnAfterRender is invoked
+			// (assuming there are markup changes)
 			if (changed)
 				OnMarkupUpdated?.Invoke();
 			if (rendered)
@@ -139,11 +167,20 @@ void IRenderedFragmentBase.OnRender(RenderEvent renderEvent)
 
 		protected void UpdateMarkup(RenderTreeFrameCollection framesCollection)
 		{
+			// The lock prevents a race condition between the renderers thread
+			// and the test frameworks thread, where one might be reading the Markup
+			// while the other is updating it due to async code in a rendered component.
 			lock (_markupAccessLock)
 			{
 				_latestRenderNodes = null;
 				var newMarkup = Htmlizer.GetHtml(ComponentId, framesCollection);
+
+				// Volatile write is necessary to ensure the updated markup
+				// is available across CPU cores. Without it, the pointer to the
+				// markup string can be stored in a CPUs register and not
+				// get updated when another CPU changes the string.
 				Volatile.Write(ref _markup, newMarkup);
+
 				if (RenderCount == 1)
 					FirstRenderMarkup = newMarkup;
 			}

From e8b483db3d19c351865db9474005fc0b1d765e0a Mon Sep 17 00:00:00 2001
From: Github Actions <actions@github.com>
Date: Tue, 1 Sep 2020 11:53:10 +0000
Subject: [PATCH 07/11] Automated dotnet-format update

---
 src/bunit.core/Rendering/RenderEvent.cs                 | 2 +-
 src/bunit.core/Rendering/TestRenderer.cs                | 4 ++--
 src/bunit.web/Extensions/RenderedFragmentExtensions.cs  | 2 +-
 src/bunit.web/Rendering/RenderedComponent.cs            | 2 +-
 tests/bunit.core.tests/Rendering/NewTestRendererTest.cs | 9 +++------
 5 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/src/bunit.core/Rendering/RenderEvent.cs b/src/bunit.core/Rendering/RenderEvent.cs
index 8e7fb8798..c9c0f94c7 100644
--- a/src/bunit.core/Rendering/RenderEvent.cs
+++ b/src/bunit.core/Rendering/RenderEvent.cs
@@ -76,7 +76,7 @@ private bool DidComponentDispose(IRenderedFragmentBase renderedComponent)
 		private (bool rendered, bool hasChanges) GetRenderAndChangeStatus(IRenderedFragmentBase renderedComponent)
 		{
 			var result = (rendered: false, hasChanges: false);
-	
+
 			GetStatus(renderedComponent.ComponentId);
 
 			return result;
diff --git a/src/bunit.core/Rendering/TestRenderer.cs b/src/bunit.core/Rendering/TestRenderer.cs
index 59c1380f1..05afff97c 100644
--- a/src/bunit.core/Rendering/TestRenderer.cs
+++ b/src/bunit.core/Rendering/TestRenderer.cs
@@ -12,7 +12,7 @@
 using Microsoft.Extensions.Logging;
 
 namespace Bunit.Rendering
-{	
+{
 	/// <summary>
 	/// Represents a bUnit <see cref="ITestRenderer"/> used to render Blazor components and fragments during bUnit tests.
 	/// </summary>
@@ -119,7 +119,7 @@ protected override Task UpdateDisplayAsync(in RenderBatch renderBatch)
 			foreach (var (key, rc) in _renderedComponents.ToArray())
 			{
 				LoadRenderTreeFrames(rc.ComponentId, renderEvent.Frames);
-				
+
 				rc.OnRender(renderEvent);
 
 				// RC can replace the instance of the component is bound
diff --git a/src/bunit.web/Extensions/RenderedFragmentExtensions.cs b/src/bunit.web/Extensions/RenderedFragmentExtensions.cs
index bcb918b31..923f167ec 100644
--- a/src/bunit.web/Extensions/RenderedFragmentExtensions.cs
+++ b/src/bunit.web/Extensions/RenderedFragmentExtensions.cs
@@ -64,7 +64,7 @@ public static IRenderedComponent<TComponent> FindComponent<TComponent>(this IRen
 				throw new ArgumentNullException(nameof(renderedFragment));
 
 			var renderer = renderedFragment.Services.GetRequiredService<ITestRenderer>();
-			return (IRenderedComponent<TComponent>)renderer.FindComponent<TComponent>(renderedFragment);			
+			return (IRenderedComponent<TComponent>)renderer.FindComponent<TComponent>(renderedFragment);
 		}
 
 		/// <summary>
diff --git a/src/bunit.web/Rendering/RenderedComponent.cs b/src/bunit.web/Rendering/RenderedComponent.cs
index 1dc553284..a61ae64fe 100644
--- a/src/bunit.web/Rendering/RenderedComponent.cs
+++ b/src/bunit.web/Rendering/RenderedComponent.cs
@@ -43,7 +43,7 @@ protected override void OnRender(RenderEvent renderEvent)
 		}
 
 		private void SetComponentAndID(RenderEvent renderEvent)
-		{			
+		{
 			if (TryFindComponent(renderEvent.Frames, ComponentId, out var id, out var component))
 			{
 				_instance = component;
diff --git a/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs b/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs
index f3a2847b2..48a00b084 100644
--- a/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs
+++ b/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs
@@ -3,20 +3,17 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
-
+using Bunit.Extensions;
 using Bunit.Rendering;
-
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Rendering;
 using Microsoft.AspNetCore.Components.RenderTree;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
-
 using Shouldly;
-using static Bunit.ComponentParameterFactory;
 using Xunit;
-using Bunit.Extensions;
-using Microsoft.Extensions.DependencyInjection;
+using static Bunit.ComponentParameterFactory;
 
 namespace Bunit.Rendering
 {

From 901db25cc07c3dda99ee6814be0adc4598ad21e5 Mon Sep 17 00:00:00 2001
From: Egil Hansen <egil@assimilated.dk>
Date: Tue, 1 Sep 2020 15:34:43 +0000
Subject: [PATCH 08/11] tests moved around

---
 .../Rendering/NewTestRendererTest.cs          | 400 ------------------
 .../Rendering/TestRendererTest.cs             | 385 ++++++++++++++++-
 2 files changed, 384 insertions(+), 401 deletions(-)
 delete mode 100644 tests/bunit.core.tests/Rendering/NewTestRendererTest.cs

diff --git a/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs b/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs
deleted file mode 100644
index 48a00b084..000000000
--- a/tests/bunit.core.tests/Rendering/NewTestRendererTest.cs
+++ /dev/null
@@ -1,400 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Bunit.Extensions;
-using Bunit.Rendering;
-using Microsoft.AspNetCore.Components;
-using Microsoft.AspNetCore.Components.Rendering;
-using Microsoft.AspNetCore.Components.RenderTree;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Logging.Abstractions;
-using Shouldly;
-using Xunit;
-using static Bunit.ComponentParameterFactory;
-
-namespace Bunit.Rendering
-{
-	public class NoChildNoParams : ComponentBase
-	{
-		public const string MARKUP = "hello world";
-		protected override void BuildRenderTree(RenderTreeBuilder builder)
-			=> builder.AddMarkupContent(0, MARKUP);
-	}
-
-	public class ThrowsDuringSetParams : ComponentBase
-	{
-		public static readonly InvalidOperationException EXCEPTION =
-			new InvalidOperationException("THROWS ON PURPOSE");
-
-		public override Task SetParametersAsync(ParameterView parameters) => throw EXCEPTION;
-	}
-
-	public class HasParams : ComponentBase
-	{
-		[Parameter] public string? Value { get; set; }
-		[Parameter] public RenderFragment? ChildContent { get; set; }
-
-		protected override void BuildRenderTree(RenderTreeBuilder builder)
-		{
-			builder.AddMarkupContent(0, Value);
-			builder.AddContent(1, ChildContent);
-		}
-	}
-
-	public class RenderTrigger : ComponentBase
-	{
-		[Parameter] public string? Value { get; set; }
-
-		public Task Trigger() => InvokeAsync(StateHasChanged);
-		public Task TriggerWithValue(string value)
-		{
-			Value = value;
-			return InvokeAsync(StateHasChanged);
-		}
-
-		protected override void BuildRenderTree(RenderTreeBuilder builder)
-		{
-			builder.AddMarkupContent(0, Value);
-		}
-	}
-
-	public class ToggleChild : ComponentBase
-	{
-		private bool _showing = true;
-
-		[Parameter] public RenderFragment? ChildContent { get; set; }
-
-		public Task DisposeChild()
-		{
-			_showing = false;
-			return InvokeAsync(StateHasChanged);
-		}
-
-		protected override void BuildRenderTree(RenderTreeBuilder builder)
-		{
-			if (_showing)
-				builder.AddContent(0, ChildContent);
-		}
-	}
-
-	internal static class TestRendererExtensions
-	{
-		public static IRenderedComponent<TComponent> RenderComponent<TComponent>(this ITestRenderer renderer, params ComponentParameter[] parameters)
-			where TComponent : IComponent
-		{
-			return (IRenderedComponent<TComponent>)renderer.RenderComponent<TComponent>(parameters);
-		}
-	}
-
-	public class NewTestRendererTest
-	{
-		private TestServiceProvider Services { get; }
-
-		public NewTestRendererTest()
-		{
-			Services = new TestServiceProvider();
-			Services.AddDefaultTestContextServices();
-			Services.AddSingleton<ITestRenderer>(srv =>
-			{
-				var rca = srv.GetRequiredService<IRenderedComponentActivator>();
-				var loggerFactory = srv.GetService<ILoggerFactory>() ?? NullLoggerFactory.Instance;
-				return new TestRenderer(rca, srv, loggerFactory);
-			});
-		}
-
-		[Fact(DisplayName = "RenderFragment re-throws exception from component")]
-		public void Test004()
-		{
-			var sut = Services.GetRequiredService<ITestRenderer>();
-			RenderFragment thowingFragment = b => { b.OpenComponent<ThrowsDuringSetParams>(0); b.CloseComponent(); };
-
-			Should.Throw<InvalidOperationException>(() => sut.RenderFragment(thowingFragment))
-				.Message.ShouldBe(ThrowsDuringSetParams.EXCEPTION.Message);
-		}
-
-		[Fact(DisplayName = "RenderComponent re-throws exception from component")]
-		public void Test003()
-		{
-			var sut = Services.GetRequiredService<ITestRenderer>();
-
-			Should.Throw<InvalidOperationException>(() => sut.RenderComponent<ThrowsDuringSetParams>())
-				.Message.ShouldBe(ThrowsDuringSetParams.EXCEPTION.Message);
-		}
-
-		[Fact(DisplayName = "Can render fragment without children and no parameters")]
-		public void Test001()
-		{
-			const string MARKUP = "<h1>hello world</h1>";
-			var sut = Services.GetRequiredService<ITestRenderer>();
-
-			var cut = (IRenderedFragment)sut.RenderFragment(builder => builder.AddMarkupContent(0, MARKUP));
-
-			cut.RenderCount.ShouldBe(1);
-			cut.Markup.ShouldBe(MARKUP);
-		}
-
-		[Fact(DisplayName = "Can render component without children and no parameters")]
-		public void Test002()
-		{
-			var sut = Services.GetRequiredService<ITestRenderer>();
-
-			var cut = sut.RenderComponent<NoChildNoParams>();
-
-			cut.RenderCount.ShouldBe(1);
-			cut.Markup.ShouldBe(NoChildNoParams.MARKUP);
-			cut.Instance.ShouldBeOfType<NoChildNoParams>();
-		}
-
-		[Fact(DisplayName = "Can render component with parameters")]
-		public void Test005()
-		{
-			const string VALUE = "FOO BAR";
-			var sut = Services.GetRequiredService<ITestRenderer>();
-
-			var cut = sut.RenderComponent<HasParams>((nameof(HasParams.Value), VALUE));
-
-			cut.Instance.Value.ShouldBe(VALUE);
-		}
-
-		[Fact(DisplayName = "Can render component with child component")]
-		public void Test006()
-		{
-			const string PARENT_VALUE = "PARENT";
-			const string CHILD_VALUE = "CHILD";
-
-			var sut = Services.GetRequiredService<ITestRenderer>();
-
-			var cut = sut.RenderComponent<HasParams>(
-				(nameof(HasParams.Value), PARENT_VALUE),
-				ChildContent<HasParams>((nameof(HasParams.Value), CHILD_VALUE))
-			);
-
-			cut.Markup.ShouldStartWith(PARENT_VALUE);
-			cut.Markup.ShouldEndWith(CHILD_VALUE);
-		}
-
-		[Fact(DisplayName = "Rendered component gets RenderCount updated on re-render")]
-		public async Task Test010()
-		{
-			var sut = Services.GetRequiredService<ITestRenderer>();
-
-			var cut = sut.RenderComponent<RenderTrigger>();
-
-			cut.RenderCount.ShouldBe(1);
-
-			await cut.Instance.Trigger();
-
-			cut.RenderCount.ShouldBe(2);
-		}
-
-		[Fact(DisplayName = "Rendered component gets Markup updated on re-render")]
-		public async Task Test011()
-		{
-			const string EXPECTED = "NOW VALUE";
-			var sut = Services.GetRequiredService<ITestRenderer>();
-
-			var cut = sut.RenderComponent<RenderTrigger>();
-
-			cut.RenderCount.ShouldBe(1);
-
-			await cut.Instance.TriggerWithValue(EXPECTED);
-
-			cut.RenderCount.ShouldBe(2);
-			cut.Markup.ShouldBe(EXPECTED);
-		}
-
-		[Fact(DisplayName = "FindComponent returns first component nested inside another rendered component")]
-		public void Test020()
-		{
-			// arrange
-			const string PARENT_VALUE = "PARENT";
-			const string CHILD_VALUE = "CHILD";
-
-			var sut = Services.GetRequiredService<ITestRenderer>();
-
-			var cut = sut.RenderComponent<HasParams>(
-				(nameof(HasParams.Value), PARENT_VALUE),
-				ChildContent<HasParams>((nameof(HasParams.Value), CHILD_VALUE))
-			);
-
-			// act
-			var childCut = (IRenderedComponent<HasParams>)sut.FindComponent<HasParams>(cut);
-
-			// assert
-			childCut.Markup.ShouldBe(CHILD_VALUE);
-			childCut.RenderCount.ShouldBe(1);
-		}
-
-		[Fact(DisplayName = "FindComponent throws if parentComponent parameter is null")]
-		public void Test021()
-		{
-			var sut = Services.GetRequiredService<ITestRenderer>();
-
-			Should.Throw<ArgumentNullException>(() => sut.FindComponent<HasParams>(null!));
-		}
-
-		[Fact(DisplayName = "FindComponent throws if component is not found")]
-		public void Test022()
-		{
-			var sut = Services.GetRequiredService<ITestRenderer>();
-			var cut = sut.RenderComponent<HasParams>();
-
-			Should.Throw<ComponentNotFoundException>(() => sut.FindComponent<HasParams>(cut));
-		}
-
-		[Fact(DisplayName = "FindComponents returns all components nested inside another rendered component")]
-		public void Test030()
-		{
-			// arrange
-			const string GRAND_PARENT_VALUE = nameof(GRAND_PARENT_VALUE);
-			const string PARENT_VALUE = nameof(PARENT_VALUE);
-			const string CHILD_VALUE = nameof(CHILD_VALUE);
-
-			var sut = Services.GetRequiredService<ITestRenderer>();
-
-			var cut = sut.RenderComponent<HasParams>(
-				(nameof(HasParams.Value), GRAND_PARENT_VALUE),
-				ChildContent<HasParams>(
-					(nameof(HasParams.Value), PARENT_VALUE),
-					ChildContent<HasParams>(
-						(nameof(HasParams.Value), CHILD_VALUE)
-					)
-				)
-			);
-
-			// act
-			var childCuts = sut.FindComponents<HasParams>(cut)
-				.Cast<IRenderedComponent<HasParams>>()
-				.ToArray();
-
-			// assert
-			childCuts[0].Markup.ShouldBe(PARENT_VALUE + CHILD_VALUE);
-			childCuts[0].RenderCount.ShouldBe(1);
-
-			childCuts[1].Markup.ShouldBe(CHILD_VALUE);
-			childCuts[1].RenderCount.ShouldBe(1);
-		}
-
-		[Fact(DisplayName = "FindComponents throws if parentComponent parameter is null")]
-		public void Test031()
-		{
-			var sut = Services.GetRequiredService<ITestRenderer>();
-
-			Should.Throw<ArgumentNullException>(() => sut.FindComponents<HasParams>(null!));
-		}
-
-		[Fact(DisplayName = "Retrieved rendered child component with FindComponent gets updated on re-render")]
-		public async Task Test040()
-		{
-			var sut = Services.GetRequiredService<ITestRenderer>();
-
-			var parent = sut.RenderComponent<HasParams>(
-				ChildContent<RenderTrigger>()
-			);
-
-			// act
-			var cut = (IRenderedComponent<RenderTrigger>)sut.FindComponent<RenderTrigger>(parent);
-
-			cut.RenderCount.ShouldBe(1);
-
-			await cut.Instance.TriggerWithValue("X");
-
-			cut.RenderCount.ShouldBe(2);
-			cut.Markup.ShouldBe("X");
-		}
-
-		[Fact(DisplayName = "Retrieved rendered child component with FindComponents gets updated on re-render")]
-		public async Task Test041()
-		{
-			var sut = Services.GetRequiredService<ITestRenderer>();
-
-			var parent = sut.RenderComponent<HasParams>(
-				ChildContent<RenderTrigger>()
-			);
-
-			// act
-			var cut = (IRenderedComponent<RenderTrigger>)sut.FindComponents<RenderTrigger>(parent).Single();
-
-			cut.RenderCount.ShouldBe(1);
-
-			await cut.Instance.TriggerWithValue("X");
-
-			cut.RenderCount.ShouldBe(2);
-			cut.Markup.ShouldBe("X");
-		}
-
-		[Fact(DisplayName = "Rendered component updates on re-renders from child components with changes in render tree")]
-		public async Task Test050()
-		{
-			// arrange
-			var sut = Services.GetRequiredService<ITestRenderer>();
-
-			var cut = sut.RenderComponent<HasParams>(
-				ChildContent<RenderTrigger>()
-			);
-			var child = (IRenderedComponent<RenderTrigger>)sut.FindComponent<RenderTrigger>(cut);
-
-			// act
-			await child.Instance.TriggerWithValue("X");
-
-			// assert
-			cut.RenderCount.ShouldBe(2);
-			cut.Markup.ShouldBe("X");
-		}
-
-		[Fact(DisplayName = "When component is disposed by renderer, getting Markup throws and IsDisposed returns true")]
-		public async Task Test060()
-		{
-			// arrange
-			var sut = Services.GetRequiredService<ITestRenderer>();
-
-			var cut = sut.RenderComponent<ToggleChild>(
-				ChildContent<NoChildNoParams>()
-			);
-			var child = (IRenderedComponent<NoChildNoParams>)sut.FindComponent<NoChildNoParams>(cut);
-
-			// act
-			await cut.Instance.DisposeChild();
-
-			// assert
-			child.IsDisposed.ShouldBeTrue();
-			Should.Throw<ComponentDisposedException>(() => child.Markup);
-		}
-
-		[Fact(DisplayName = "Rendered component updates itself if a child's child is disposed")]
-		public async Task Test061()
-		{
-			// arrange
-			var sut = Services.GetRequiredService<ITestRenderer>();
-
-			var cut = sut.RenderComponent<ToggleChild>(
-				ChildContent<ToggleChild>(
-					ChildContent<NoChildNoParams>()
-				)
-			);
-			var child = (IRenderedComponent<ToggleChild>)sut.FindComponent<ToggleChild>(cut);
-			var childChild = (IRenderedComponent<NoChildNoParams>)sut.FindComponent<NoChildNoParams>(cut);
-
-			// act
-			await child.Instance.DisposeChild();
-
-			// assert
-			childChild.IsDisposed.ShouldBeTrue();
-			cut.Markup.ShouldBe(string.Empty);
-		}
-
-		[Fact(DisplayName = "When test renderer is disposed, so is all rendered components")]
-		public void Test070()
-		{
-			var sut = (TestRenderer)Services.GetRequiredService<ITestRenderer>();
-			var cut = sut.RenderComponent<NoChildNoParams>();
-
-			sut.Dispose();
-
-			cut.IsDisposed.ShouldBeTrue();
-		}
-	}
-}
diff --git a/tests/bunit.core.tests/Rendering/TestRendererTest.cs b/tests/bunit.core.tests/Rendering/TestRendererTest.cs
index 8235d4d43..7c191b2e2 100644
--- a/tests/bunit.core.tests/Rendering/TestRendererTest.cs
+++ b/tests/bunit.core.tests/Rendering/TestRendererTest.cs
@@ -1,21 +1,404 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
-
+using Bunit.Extensions;
 using Bunit.TestAssets.SampleComponents;
 
 using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Rendering;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 
 using Shouldly;
 
 using Xunit;
+using static Bunit.ComponentParameterFactory;
 
 namespace Bunit.Rendering
 {
+
+	public class NoChildNoParams : ComponentBase
+	{
+		public const string MARKUP = "hello world";
+		protected override void BuildRenderTree(RenderTreeBuilder builder)
+			=> builder.AddMarkupContent(0, MARKUP);
+	}
+
+	public class ThrowsDuringSetParams : ComponentBase
+	{
+		public static readonly InvalidOperationException EXCEPTION =
+			new InvalidOperationException("THROWS ON PURPOSE");
+
+		public override Task SetParametersAsync(ParameterView parameters) => throw EXCEPTION;
+	}
+
+	public class HasParams : ComponentBase
+	{
+		[Parameter] public string? Value { get; set; }
+		[Parameter] public RenderFragment? ChildContent { get; set; }
+
+		protected override void BuildRenderTree(RenderTreeBuilder builder)
+		{
+			builder.AddMarkupContent(0, Value);
+			builder.AddContent(1, ChildContent);
+		}
+	}
+
+	public class RenderTrigger : ComponentBase
+	{
+		[Parameter] public string? Value { get; set; }
+
+		public Task Trigger() => InvokeAsync(StateHasChanged);
+		public Task TriggerWithValue(string value)
+		{
+			Value = value;
+			return InvokeAsync(StateHasChanged);
+		}
+
+		protected override void BuildRenderTree(RenderTreeBuilder builder)
+		{
+			builder.AddMarkupContent(0, Value);
+		}
+	}
+
+	public class ToggleChild : ComponentBase
+	{
+		private bool _showing = true;
+
+		[Parameter] public RenderFragment? ChildContent { get; set; }
+
+		public Task DisposeChild()
+		{
+			_showing = false;
+			return InvokeAsync(StateHasChanged);
+		}
+
+		protected override void BuildRenderTree(RenderTreeBuilder builder)
+		{
+			if (_showing)
+				builder.AddContent(0, ChildContent);
+		}
+	}
+
+	internal static class TestRendererExtensions
+	{
+		public static IRenderedComponent<TComponent> RenderComponent<TComponent>(this ITestRenderer renderer, params ComponentParameter[] parameters)
+			where TComponent : IComponent
+		{
+			return (IRenderedComponent<TComponent>)renderer.RenderComponent<TComponent>(parameters);
+		}
+	}
+
 	public class TestRendererTest
 	{
+		private TestServiceProvider Services { get; }
+
+		public TestRendererTest()
+		{
+			Services = new TestServiceProvider();
+			Services.AddDefaultTestContextServices();
+			Services.AddSingleton<ITestRenderer>(srv =>
+			{
+				var rca = srv.GetRequiredService<IRenderedComponentActivator>();
+				var loggerFactory = srv.GetService<ILoggerFactory>() ?? NullLoggerFactory.Instance;
+				return new TestRenderer(rca, srv, loggerFactory);
+			});
+		}
+
+		[Fact(DisplayName = "RenderFragment re-throws exception from component")]
+		public void Test004()
+		{
+			var sut = Services.GetRequiredService<ITestRenderer>();
+			RenderFragment thowingFragment = b => { b.OpenComponent<ThrowsDuringSetParams>(0); b.CloseComponent(); };
+
+			Should.Throw<InvalidOperationException>(() => sut.RenderFragment(thowingFragment))
+				.Message.ShouldBe(ThrowsDuringSetParams.EXCEPTION.Message);
+		}
+
+		[Fact(DisplayName = "RenderComponent re-throws exception from component")]
+		public void Test003()
+		{
+			var sut = Services.GetRequiredService<ITestRenderer>();
+
+			Should.Throw<InvalidOperationException>(() => sut.RenderComponent<ThrowsDuringSetParams>())
+				.Message.ShouldBe(ThrowsDuringSetParams.EXCEPTION.Message);
+		}
+
+		[Fact(DisplayName = "Can render fragment without children and no parameters")]
+		public void Test001()
+		{
+			const string MARKUP = "<h1>hello world</h1>";
+			var sut = Services.GetRequiredService<ITestRenderer>();
+
+			var cut = (IRenderedFragment)sut.RenderFragment(builder => builder.AddMarkupContent(0, MARKUP));
+
+			cut.RenderCount.ShouldBe(1);
+			cut.Markup.ShouldBe(MARKUP);
+		}
+
+		[Fact(DisplayName = "Can render component without children and no parameters")]
+		public void Test002()
+		{
+			var sut = Services.GetRequiredService<ITestRenderer>();
+
+			var cut = sut.RenderComponent<NoChildNoParams>();
+
+			cut.RenderCount.ShouldBe(1);
+			cut.Markup.ShouldBe(NoChildNoParams.MARKUP);
+			cut.Instance.ShouldBeOfType<NoChildNoParams>();
+		}
+
+		[Fact(DisplayName = "Can render component with parameters")]
+		public void Test005()
+		{
+			const string VALUE = "FOO BAR";
+			var sut = Services.GetRequiredService<ITestRenderer>();
+
+			var cut = sut.RenderComponent<HasParams>((nameof(HasParams.Value), VALUE));
+
+			cut.Instance.Value.ShouldBe(VALUE);
+		}
+
+		[Fact(DisplayName = "Can render component with child component")]
+		public void Test006()
+		{
+			const string PARENT_VALUE = "PARENT";
+			const string CHILD_VALUE = "CHILD";
+
+			var sut = Services.GetRequiredService<ITestRenderer>();
+
+			var cut = sut.RenderComponent<HasParams>(
+				(nameof(HasParams.Value), PARENT_VALUE),
+				ChildContent<HasParams>((nameof(HasParams.Value), CHILD_VALUE))
+			);
+
+			cut.Markup.ShouldStartWith(PARENT_VALUE);
+			cut.Markup.ShouldEndWith(CHILD_VALUE);
+		}
+
+		[Fact(DisplayName = "Rendered component gets RenderCount updated on re-render")]
+		public async Task Test010()
+		{
+			var sut = Services.GetRequiredService<ITestRenderer>();
+
+			var cut = sut.RenderComponent<RenderTrigger>();
+
+			cut.RenderCount.ShouldBe(1);
+
+			await cut.Instance.Trigger();
+
+			cut.RenderCount.ShouldBe(2);
+		}
+
+		[Fact(DisplayName = "Rendered component gets Markup updated on re-render")]
+		public async Task Test011()
+		{
+			const string EXPECTED = "NOW VALUE";
+			var sut = Services.GetRequiredService<ITestRenderer>();
+
+			var cut = sut.RenderComponent<RenderTrigger>();
+
+			cut.RenderCount.ShouldBe(1);
+
+			await cut.Instance.TriggerWithValue(EXPECTED);
+
+			cut.RenderCount.ShouldBe(2);
+			cut.Markup.ShouldBe(EXPECTED);
+		}
+
+		[Fact(DisplayName = "FindComponent returns first component nested inside another rendered component")]
+		public void Test020()
+		{
+			// arrange
+			const string PARENT_VALUE = "PARENT";
+			const string CHILD_VALUE = "CHILD";
+
+			var sut = Services.GetRequiredService<ITestRenderer>();
+
+			var cut = sut.RenderComponent<HasParams>(
+				(nameof(HasParams.Value), PARENT_VALUE),
+				ChildContent<HasParams>((nameof(HasParams.Value), CHILD_VALUE))
+			);
+
+			// act
+			var childCut = (IRenderedComponent<HasParams>)sut.FindComponent<HasParams>(cut);
+
+			// assert
+			childCut.Markup.ShouldBe(CHILD_VALUE);
+			childCut.RenderCount.ShouldBe(1);
+		}
+
+		[Fact(DisplayName = "FindComponent throws if parentComponent parameter is null")]
+		public void Test021()
+		{
+			var sut = Services.GetRequiredService<ITestRenderer>();
+
+			Should.Throw<ArgumentNullException>(() => sut.FindComponent<HasParams>(null!));
+		}
+
+		[Fact(DisplayName = "FindComponent throws if component is not found")]
+		public void Test022()
+		{
+			var sut = Services.GetRequiredService<ITestRenderer>();
+			var cut = sut.RenderComponent<HasParams>();
+
+			Should.Throw<ComponentNotFoundException>(() => sut.FindComponent<HasParams>(cut));
+		}
+
+		[Fact(DisplayName = "FindComponents returns all components nested inside another rendered component")]
+		public void Test030()
+		{
+			// arrange
+			const string GRAND_PARENT_VALUE = nameof(GRAND_PARENT_VALUE);
+			const string PARENT_VALUE = nameof(PARENT_VALUE);
+			const string CHILD_VALUE = nameof(CHILD_VALUE);
+
+			var sut = Services.GetRequiredService<ITestRenderer>();
+
+			var cut = sut.RenderComponent<HasParams>(
+				(nameof(HasParams.Value), GRAND_PARENT_VALUE),
+				ChildContent<HasParams>(
+					(nameof(HasParams.Value), PARENT_VALUE),
+					ChildContent<HasParams>(
+						(nameof(HasParams.Value), CHILD_VALUE)
+					)
+				)
+			);
+
+			// act
+			var childCuts = sut.FindComponents<HasParams>(cut)
+				.Cast<IRenderedComponent<HasParams>>()
+				.ToArray();
+
+			// assert
+			childCuts[0].Markup.ShouldBe(PARENT_VALUE + CHILD_VALUE);
+			childCuts[0].RenderCount.ShouldBe(1);
+
+			childCuts[1].Markup.ShouldBe(CHILD_VALUE);
+			childCuts[1].RenderCount.ShouldBe(1);
+		}
+
+		[Fact(DisplayName = "FindComponents throws if parentComponent parameter is null")]
+		public void Test031()
+		{
+			var sut = Services.GetRequiredService<ITestRenderer>();
+
+			Should.Throw<ArgumentNullException>(() => sut.FindComponents<HasParams>(null!));
+		}
+
+		[Fact(DisplayName = "Retrieved rendered child component with FindComponent gets updated on re-render")]
+		public async Task Test040()
+		{
+			var sut = Services.GetRequiredService<ITestRenderer>();
+
+			var parent = sut.RenderComponent<HasParams>(
+				ChildContent<RenderTrigger>()
+			);
+
+			// act
+			var cut = (IRenderedComponent<RenderTrigger>)sut.FindComponent<RenderTrigger>(parent);
+
+			cut.RenderCount.ShouldBe(1);
+
+			await cut.Instance.TriggerWithValue("X");
+
+			cut.RenderCount.ShouldBe(2);
+			cut.Markup.ShouldBe("X");
+		}
+
+		[Fact(DisplayName = "Retrieved rendered child component with FindComponents gets updated on re-render")]
+		public async Task Test041()
+		{
+			var sut = Services.GetRequiredService<ITestRenderer>();
+
+			var parent = sut.RenderComponent<HasParams>(
+				ChildContent<RenderTrigger>()
+			);
+
+			// act
+			var cut = (IRenderedComponent<RenderTrigger>)sut.FindComponents<RenderTrigger>(parent).Single();
+
+			cut.RenderCount.ShouldBe(1);
+
+			await cut.Instance.TriggerWithValue("X");
+
+			cut.RenderCount.ShouldBe(2);
+			cut.Markup.ShouldBe("X");
+		}
+
+		[Fact(DisplayName = "Rendered component updates on re-renders from child components with changes in render tree")]
+		public async Task Test050()
+		{
+			// arrange
+			var sut = Services.GetRequiredService<ITestRenderer>();
+
+			var cut = sut.RenderComponent<HasParams>(
+				ChildContent<RenderTrigger>()
+			);
+			var child = (IRenderedComponent<RenderTrigger>)sut.FindComponent<RenderTrigger>(cut);
+
+			// act
+			await child.Instance.TriggerWithValue("X");
+
+			// assert
+			cut.RenderCount.ShouldBe(2);
+			cut.Markup.ShouldBe("X");
+		}
+
+		[Fact(DisplayName = "When component is disposed by renderer, getting Markup throws and IsDisposed returns true")]
+		public async Task Test060()
+		{
+			// arrange
+			var sut = Services.GetRequiredService<ITestRenderer>();
+
+			var cut = sut.RenderComponent<ToggleChild>(
+				ChildContent<NoChildNoParams>()
+			);
+			var child = (IRenderedComponent<NoChildNoParams>)sut.FindComponent<NoChildNoParams>(cut);
+
+			// act
+			await cut.Instance.DisposeChild();
+
+			// assert
+			child.IsDisposed.ShouldBeTrue();
+			Should.Throw<ComponentDisposedException>(() => child.Markup);
+		}
+
+		[Fact(DisplayName = "Rendered component updates itself if a child's child is disposed")]
+		public async Task Test061()
+		{
+			// arrange
+			var sut = Services.GetRequiredService<ITestRenderer>();
+
+			var cut = sut.RenderComponent<ToggleChild>(
+				ChildContent<ToggleChild>(
+					ChildContent<NoChildNoParams>()
+				)
+			);
+			var child = (IRenderedComponent<ToggleChild>)sut.FindComponent<ToggleChild>(cut);
+			var childChild = (IRenderedComponent<NoChildNoParams>)sut.FindComponent<NoChildNoParams>(cut);
+
+			// act
+			await child.Instance.DisposeChild();
+
+			// assert
+			childChild.IsDisposed.ShouldBeTrue();
+			cut.Markup.ShouldBe(string.Empty);
+		}
+
+		[Fact(DisplayName = "When test renderer is disposed, so is all rendered components")]
+		public void Test070()
+		{
+			var sut = (TestRenderer)Services.GetRequiredService<ITestRenderer>();
+			var cut = sut.RenderComponent<NoChildNoParams>();
+
+			sut.Dispose();
+
+			cut.IsDisposed.ShouldBeTrue();
+		}
+
 		[Fact(DisplayName = "Can render component that awaits uncompleted task in OnInitializedAsync")]
 		public void Test100()
 		{

From f14098821f38b76aab2cc09cb39d23892ecba55c Mon Sep 17 00:00:00 2001
From: Egil Hansen <egil@assimilated.dk>
Date: Tue, 1 Sep 2020 16:21:00 +0000
Subject: [PATCH 09/11] Simplified test context services registration

---
 src/bunit.core/TestContextBase.cs               |  7 +------
 src/bunit.web/Diffing/HtmlParser.cs             |  2 +-
 .../Extensions/TestServiceProviderExtensions.cs | 17 ++++++++---------
 .../Rendering/TestRendererTest.cs               |  4 +++-
 4 files changed, 13 insertions(+), 17 deletions(-)

diff --git a/src/bunit.core/TestContextBase.cs b/src/bunit.core/TestContextBase.cs
index 70e0126f7..da03312ad 100644
--- a/src/bunit.core/TestContextBase.cs
+++ b/src/bunit.core/TestContextBase.cs
@@ -38,12 +38,7 @@ public ITestRenderer Renderer
 		public TestContextBase()
 		{
 			Services = new TestServiceProvider();
-			Services.AddSingleton<ITestRenderer>(srv =>
-			{
-				var rca = srv.GetRequiredService<IRenderedComponentActivator>();
-				var loggerFactory = srv.GetService<ILoggerFactory>() ?? NullLoggerFactory.Instance;
-				return new TestRenderer(rca, srv, loggerFactory);
-			});
+			Services.AddSingleton<ITestRenderer, TestRenderer>();
 		}
 
 		/// <inheritdoc/>
diff --git a/src/bunit.web/Diffing/HtmlParser.cs b/src/bunit.web/Diffing/HtmlParser.cs
index fd6112f8b..378f2019c 100644
--- a/src/bunit.web/Diffing/HtmlParser.cs
+++ b/src/bunit.web/Diffing/HtmlParser.cs
@@ -42,7 +42,7 @@ public HtmlParser(ITestRenderer testRenderer, HtmlComparer htmlComparer)
 		{
 			var config = Configuration.Default
 				.WithCss()
-				.With(testRenderer)
+				.With(testRenderer) // added to allow elements to find the renderer to trigger events
 				.With(htmlComparer)
 				.With(this);
 
diff --git a/src/bunit.web/Extensions/TestServiceProviderExtensions.cs b/src/bunit.web/Extensions/TestServiceProviderExtensions.cs
index 955ed7570..8b916c579 100644
--- a/src/bunit.web/Extensions/TestServiceProviderExtensions.cs
+++ b/src/bunit.web/Extensions/TestServiceProviderExtensions.cs
@@ -5,6 +5,8 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Components.Authorization;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.JSInterop;
 
 namespace Bunit.Extensions
@@ -19,15 +21,12 @@ public static class TestServiceProviderExtensions
 		/// </summary>
 		public static IServiceCollection AddDefaultTestContextServices(this IServiceCollection services)
 		{
-			services.AddSingleton<AuthenticationStateProvider>(new PlaceholderAuthenticationStateProvider());
-			services.AddSingleton<IAuthorizationService>(new PlaceholderAuthorizationService());
-			services.AddSingleton<IJSRuntime>(new PlaceholderJSRuntime());
-			services.AddSingleton<HtmlComparer>(srv => new HtmlComparer());
-			services.AddSingleton<HtmlParser>(srv => new HtmlParser(
-					srv.GetRequiredService<ITestRenderer>(),
-					srv.GetRequiredService<HtmlComparer>()
-				)
-			);
+			services.AddSingleton<ILoggerFactory>(NullLoggerFactory.Instance);
+			services.AddSingleton<AuthenticationStateProvider, PlaceholderAuthenticationStateProvider>();
+			services.AddSingleton<IAuthorizationService, PlaceholderAuthorizationService>();
+			services.AddSingleton<IJSRuntime, PlaceholderJSRuntime>();
+			services.AddSingleton<HtmlComparer>();
+			services.AddSingleton<HtmlParser>();
 			services.AddSingleton<IRenderedComponentActivator, RenderedComponentActivator>();
 			return services;
 		}
diff --git a/tests/bunit.core.tests/Rendering/TestRendererTest.cs b/tests/bunit.core.tests/Rendering/TestRendererTest.cs
index 7c191b2e2..8a1cdf438 100644
--- a/tests/bunit.core.tests/Rendering/TestRendererTest.cs
+++ b/tests/bunit.core.tests/Rendering/TestRendererTest.cs
@@ -195,15 +195,17 @@ public async Task Test010()
 		[Fact(DisplayName = "Rendered component gets Markup updated on re-render")]
 		public async Task Test011()
 		{
+			// arrange
 			const string EXPECTED = "NOW VALUE";
 			var sut = Services.GetRequiredService<ITestRenderer>();
-
 			var cut = sut.RenderComponent<RenderTrigger>();
 
 			cut.RenderCount.ShouldBe(1);
 
+			// act
 			await cut.Instance.TriggerWithValue(EXPECTED);
 
+			// assert
 			cut.RenderCount.ShouldBe(2);
 			cut.Markup.ShouldBe(EXPECTED);
 		}

From 0b12ccc6baa496ec46661083a6c9d52a7ecd5903 Mon Sep 17 00:00:00 2001
From: Egil Hansen <egil@assimilated.dk>
Date: Tue, 1 Sep 2020 22:02:26 +0000
Subject: [PATCH 10/11] Tweaks to code, updates to changelog

---
 CHANGELOG.md                                  |  4 ++
 .../RenderedComponentRenderExtensions.cs      |  4 +-
 .../Rendering/IRenderedComponentActivator.cs  |  2 +-
 src/bunit.core/Rendering/TestRenderer.cs      | 18 ++++--
 src/bunit.core/Rendering/TestRenderer.log.cs  | 14 -----
 src/bunit.web/Diffing/BlazorDiffingHelpers.cs |  2 +-
 src/bunit.web/Diffing/DiffMarkupFormatter.cs  |  2 +-
 src/bunit.web/Diffing/HtmlComparer.cs         |  2 +-
 .../GeneralEventDispatchExtensions.cs         |  1 -
 .../Extensions/TestRendererExtensions.cs      | 59 +++++++++++++++++++
 .../Rendering/RenderedComponentActivator.cs   |  2 +-
 src/bunit.web/TestContext.cs                  | 15 +----
 .../Rendering/TestRendererTest.cs             | 17 +-----
 13 files changed, 86 insertions(+), 56 deletions(-)
 delete mode 100644 src/bunit.core/Rendering/TestRenderer.log.cs
 create mode 100644 src/bunit.web/Extensions/TestRendererExtensions.cs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a31a02826..40fd1b414 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,8 @@ List of new features.
 ### Changed
 List of changes in existing functionality.
 
+- Related to [#189](https://github.com/egil/bUnit/issues/189), a bunch of the core `ITestRenderer` and related types have changed. The internals of `ITestRenderer` is now less exposed and the test renderer is now in control of when rendered components and rendered fragments are created, and when they are updated. This enables the test renderer to protect against race conditions when the `FindComponent`, `FindComponents`, `RenderFragment`, and `RenderComponent` methods are called.
+
 ### Deprecated
 List of soon-to-be removed features.
 
@@ -21,6 +23,8 @@ List of now removed features.
 ### Fixed
 List of any bug fixes.
 
+- Fixes [#189](https://github.com/egil/bUnit/issues/189): The test renderer did not correctly protect against a race condition during initial rendering of a component, and that could in some rare circumstances cause a test to fail when it should not. This has been addressed in this release with a major rewrite of the test renderer, which now controls and owns the rendered component and rendered fragment instances which is created when a component is rendered. By [@egil](https://github.com/egil) in [#201](https://github.com/egil/bUnit/pull/201). Credits to [@Smurf-IV](https://github.com/Smurf-IV) for reporting and helping investigate this issue.
+
 ### Security
 List of fixed security vulnerabilities.
 
diff --git a/src/bunit.core/Extensions/RenderedComponentRenderExtensions.cs b/src/bunit.core/Extensions/RenderedComponentRenderExtensions.cs
index 4809acf80..d5a9432a3 100644
--- a/src/bunit.core/Extensions/RenderedComponentRenderExtensions.cs
+++ b/src/bunit.core/Extensions/RenderedComponentRenderExtensions.cs
@@ -53,7 +53,7 @@ public static void SetParametersAndRender<TComponent>(this IRenderedComponentBas
 		/// <param name="renderedComponent">The rendered component to re-render with new parameters</param>
 		/// <param name="parameterBuilder">An action that receives a <see cref="ComponentParameterBuilder{TComponent}"/>.</param>
 		public static void SetParametersAndRender<TComponent>(this IRenderedComponentBase<TComponent> renderedComponent, Action<ComponentParameterBuilder<TComponent>> parameterBuilder)
-						where TComponent : IComponent
+			where TComponent : IComponent
 		{
 			if (renderedComponent is null)
 				throw new ArgumentNullException(nameof(renderedComponent));
@@ -70,7 +70,7 @@ public static void SetParametersAndRender<TComponent>(this IRenderedComponentBas
 		private static ParameterView ToParameterView(IReadOnlyList<ComponentParameter> parameters)
 		{
 			var parameterView = ParameterView.Empty;
-			if (parameters.Any())
+			if (parameters.Count > 0)
 			{
 				var paramDict = new Dictionary<string, object>();
 				foreach (var param in parameters)
diff --git a/src/bunit.core/Rendering/IRenderedComponentActivator.cs b/src/bunit.core/Rendering/IRenderedComponentActivator.cs
index c0c776a26..e8c6b01b7 100644
--- a/src/bunit.core/Rendering/IRenderedComponentActivator.cs
+++ b/src/bunit.core/Rendering/IRenderedComponentActivator.cs
@@ -11,7 +11,7 @@ public interface IRenderedComponentActivator
 		/// <summary>
 		/// Creates an <see cref="IRenderedFragmentBase"/> with the specified <paramref name="componentId"/>.
 		/// </summary>
-		IRenderedFragmentBase CreateRenderedComponent(int componentId);
+		IRenderedFragmentBase CreateRenderedFragment(int componentId);
 
 		/// <summary>
 		/// Creates an <see cref="IRenderedComponentBase{TComponent}"/> with the specified <paramref name="componentId"/>.
diff --git a/src/bunit.core/Rendering/TestRenderer.cs b/src/bunit.core/Rendering/TestRenderer.cs
index 05afff97c..02a7f5d43 100644
--- a/src/bunit.core/Rendering/TestRenderer.cs
+++ b/src/bunit.core/Rendering/TestRenderer.cs
@@ -39,15 +39,15 @@ public TestRenderer(IRenderedComponentActivator activator, IServiceProvider serv
 		/// <inheritdoc/>
 		public IRenderedFragmentBase RenderFragment(RenderFragment renderFragment)
 		{
-			return Render(renderFragment, id => _activator.CreateRenderedComponent(id));
+			return Render(renderFragment, id => _activator.CreateRenderedFragment(id));
 		}
 
 		/// <inheritdoc/>
-		public IRenderedComponentBase<TComponent> RenderComponent<TComponent>(IEnumerable<ComponentParameter> componentParameters)
+		public IRenderedComponentBase<TComponent> RenderComponent<TComponent>(IEnumerable<ComponentParameter> parameters)
 			where TComponent : IComponent
 		{
-			var parameters = componentParameters.ToComponentRenderFragment<TComponent>();
-			return Render(parameters, id => _activator.CreateRenderedComponent<TComponent>(id));
+			var fragment = parameters.ToComponentRenderFragment<TComponent>();
+			return Render(fragment, id => _activator.CreateRenderedComponent<TComponent>(id));
 		}
 
 		/// <inheritdoc/>
@@ -152,6 +152,7 @@ private TResult Render<TResult>(RenderFragment renderFragment, Func<int, TResult
 			where TResult : IRenderedFragmentBase
 		{
 			TResult renderedComponent = default!;
+
 			var task = Dispatcher.InvokeAsync(() =>
 			{
 				var root = new WrapperComponent(renderFragment);
@@ -161,7 +162,8 @@ private TResult Render<TResult>(RenderFragment renderFragment, Func<int, TResult
 				root.Render();
 			});
 
-			Debug.Assert(task.IsCompleted, "The render task did not complete as expected");
+			task.Wait();
+
 			AssertNoUnhandledExceptions();
 
 			return renderedComponent!;
@@ -263,5 +265,11 @@ private void AssertNoUnhandledExceptions()
 				ExceptionDispatchInfo.Capture(unhandled).Throw();
 			}
 		}
+
+		private void LogUnhandledException(Exception unhandled)
+		{
+			var evt = new EventId(3, nameof(AssertNoUnhandledExceptions));
+			_logger.LogError(evt, unhandled, $"An unhandled exception happened during rendering: {unhandled.Message}{Environment.NewLine}{unhandled.StackTrace}");
+		}
 	}
 }
diff --git a/src/bunit.core/Rendering/TestRenderer.log.cs b/src/bunit.core/Rendering/TestRenderer.log.cs
deleted file mode 100644
index 8abe3c672..000000000
--- a/src/bunit.core/Rendering/TestRenderer.log.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-using System;
-using Microsoft.Extensions.Logging;
-
-namespace Bunit.Rendering
-{
-	public partial class TestRenderer
-	{
-		private void LogUnhandledException(Exception unhandled)
-		{
-			var evt = new EventId(3, nameof(AssertNoUnhandledExceptions));
-			_logger.LogError(evt, unhandled, $"An unhandled exception happened during rendering: {unhandled.Message}{Environment.NewLine}{unhandled.StackTrace}");
-		}
-	}
-}
diff --git a/src/bunit.web/Diffing/BlazorDiffingHelpers.cs b/src/bunit.web/Diffing/BlazorDiffingHelpers.cs
index 429fb6ea7..93c2a158a 100644
--- a/src/bunit.web/Diffing/BlazorDiffingHelpers.cs
+++ b/src/bunit.web/Diffing/BlazorDiffingHelpers.cs
@@ -10,7 +10,7 @@ namespace Bunit.Diffing
 	public static class BlazorDiffingHelpers
 	{
 		/// <summary>
-		/// Represents a diffing filter that removes all special Blazor attributes added by the <see cref="TestRenderer"/>/<see cref="Htmlizer"/>.
+		/// Represents a diffing filter that removes all special Blazor attributes added by the /<see cref="Htmlizer"/>.
 		/// </summary>
 		public static FilterDecision BlazorEventHandlerIdAttrFilter(in AttributeComparisonSource attrSource, FilterDecision currentDecision)
 		{
diff --git a/src/bunit.web/Diffing/DiffMarkupFormatter.cs b/src/bunit.web/Diffing/DiffMarkupFormatter.cs
index 7ef881b04..f8cdb8c10 100644
--- a/src/bunit.web/Diffing/DiffMarkupFormatter.cs
+++ b/src/bunit.web/Diffing/DiffMarkupFormatter.cs
@@ -9,7 +9,7 @@
 namespace Bunit.Diffing
 {
 	/// <summary>
-	/// A markup formatter, that skips any special Blazor attributes added by the <see cref="TestRenderer"/>/<see cref="Htmlizer"/>.
+	/// A markup formatter, that skips any special Blazor attributes added by the <see cref="Htmlizer"/>.
 	/// </summary>
 	public class DiffMarkupFormatter : PrettyMarkupFormatter, IMarkupFormatter
 	{
diff --git a/src/bunit.web/Diffing/HtmlComparer.cs b/src/bunit.web/Diffing/HtmlComparer.cs
index 3240d1a21..5e7d385e3 100644
--- a/src/bunit.web/Diffing/HtmlComparer.cs
+++ b/src/bunit.web/Diffing/HtmlComparer.cs
@@ -12,7 +12,7 @@
 namespace Bunit.Diffing
 {
 	/// <summary>
-	/// Represents a test HTML comparer, that is configured to work with markup generated by the <see cref="TestRenderer"/> and <see cref="Htmlizer"/> classes.
+	/// Represents a test HTML comparer, that is configured to work with markup generated by the <see cref="ITestRenderer"/> and <see cref="Htmlizer"/> classes.
 	/// </summary>
 	public sealed class HtmlComparer
 	{
diff --git a/src/bunit.web/EventDispatchExtensions/GeneralEventDispatchExtensions.cs b/src/bunit.web/EventDispatchExtensions/GeneralEventDispatchExtensions.cs
index 70a6ca82d..360ff6467 100644
--- a/src/bunit.web/EventDispatchExtensions/GeneralEventDispatchExtensions.cs
+++ b/src/bunit.web/EventDispatchExtensions/GeneralEventDispatchExtensions.cs
@@ -24,7 +24,6 @@ public static class GeneralEventDispatchExtensions
 		/// <param name="eventName">The name of the event to raise (using on-form, e.g. <c>onclick</c>).</param>
 		/// <param name="eventArgs">The event arguments to pass to the event handler</param>
 		/// <returns></returns>
-		[SuppressMessage("Usage", "BL0006:Do not use RenderTree types", Justification = "<Pending>")]
 		public static Task TriggerEventAsync(this IElement element, string eventName, EventArgs eventArgs)
 		{
 			if (element is null)
diff --git a/src/bunit.web/Extensions/TestRendererExtensions.cs b/src/bunit.web/Extensions/TestRendererExtensions.cs
new file mode 100644
index 000000000..f19257c9e
--- /dev/null
+++ b/src/bunit.web/Extensions/TestRendererExtensions.cs
@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Bunit.Rendering;
+using Microsoft.AspNetCore.Components;
+
+namespace Bunit.Extensions
+{
+	/// <summary>
+	/// Helper methods that make it easier to work directly with a <see cref="ITestRenderer"/>
+	/// in bUnit web.
+	/// </summary>
+    public static class TestRendererExtensions
+    {
+		/// <summary>
+		/// Renders a <typeparamref name="TComponent"/> with the parameters <paramref name="parameters"/> passed to it.
+		/// </summary>
+		/// <typeparam name = "TComponent" > The type of component to render.</typeparam>
+		/// <param name="renderer">The renderer to use.</param>
+		/// <param name="parameters">The parameters to pass to the component.</param>
+		/// <returns>A <see cref="IRenderedComponent{TComponent}"/> that provides access to the rendered component.</returns>
+		public static IRenderedComponent<TComponent> RenderComponent<TComponent>(this ITestRenderer renderer, params ComponentParameter[] parameters)
+			where TComponent : IComponent
+		{
+			if (renderer is null) throw new ArgumentNullException(nameof(renderer));
+
+			var resultBase = renderer.RenderComponent<TComponent>(parameters);
+			if (resultBase is IRenderedComponent<TComponent> result)
+				return result;
+			else
+				throw new InvalidOperationException($"The renderer did not produce the expected type. Is the test renderer using the expected {nameof(IRenderedComponentActivator)}?");
+		}
+
+		/// <summary>
+		/// Renders a <typeparamref name="TComponent"/> with the parameters build with the <paramref name="parameterBuilder"/> passed to it.
+		/// </summary>
+		/// <typeparam name = "TComponent" > The type of component to render.</typeparam>
+		/// <param name="renderer">The renderer to use.</param>
+		/// <param name="parameterBuilder">The a builder to create parameters to pass to the component.</param>
+		/// <returns>A <see cref="IRenderedComponent{TComponent}"/> that provides access to the rendered component.</returns>
+		public static IRenderedComponent<TComponent> RenderComponent<TComponent>(this ITestRenderer renderer, Action<ComponentParameterBuilder<TComponent>> parameterBuilder)
+			where TComponent : IComponent
+		{
+			if (renderer is null) throw new ArgumentNullException(nameof(renderer));
+			if (parameterBuilder is null) throw new ArgumentNullException(nameof(parameterBuilder));
+
+			var builder = new ComponentParameterBuilder<TComponent>();
+			parameterBuilder(builder);
+
+			var resultBase = renderer.RenderComponent<TComponent>(builder.Build());
+			if (resultBase is IRenderedComponent<TComponent> result)
+				return result;
+			else
+				throw new InvalidOperationException($"The renderer did not produce the expected type. Is the test renderer using the expected {nameof(IRenderedComponentActivator)}?");
+		}
+	}
+}
diff --git a/src/bunit.web/Rendering/RenderedComponentActivator.cs b/src/bunit.web/Rendering/RenderedComponentActivator.cs
index d6d6580d2..48ec22242 100644
--- a/src/bunit.web/Rendering/RenderedComponentActivator.cs
+++ b/src/bunit.web/Rendering/RenderedComponentActivator.cs
@@ -20,7 +20,7 @@ public RenderedComponentActivator(IServiceProvider services)
 		}
 
 		/// <inheritdoc/>
-		public IRenderedFragmentBase CreateRenderedComponent(int componentId)
+		public IRenderedFragmentBase CreateRenderedFragment(int componentId)
 			=> new RenderedFragment(componentId, _services);
 
 		/// <inheritdoc/>
diff --git a/src/bunit.web/TestContext.cs b/src/bunit.web/TestContext.cs
index e0e91684d..be27493fe 100644
--- a/src/bunit.web/TestContext.cs
+++ b/src/bunit.web/TestContext.cs
@@ -27,10 +27,7 @@ public TestContext()
 		/// <param name="parameters">Parameters to pass to the component when it is rendered</param>
 		/// <returns>The rendered <typeparamref name="TComponent"/></returns>
 		public IRenderedComponent<TComponent> RenderComponent<TComponent>(params ComponentParameter[] parameters) where TComponent : IComponent
-		{
-			var renderedFragment = Renderer.RenderComponent<TComponent>(parameters);
-			return (IRenderedComponent<TComponent>)renderedFragment;
-		}
+			=> TestRendererExtensions.RenderComponent<TComponent>(Renderer, parameters);
 
 		/// <summary>
 		/// Instantiates and performs a first render of a component of type <typeparamref name="TComponent"/>.
@@ -39,14 +36,6 @@ public IRenderedComponent<TComponent> RenderComponent<TComponent>(params Compone
 		/// <param name="parameterBuilder">The ComponentParameterBuilder action to add type safe parameters to pass to the component when it is rendered</param>
 		/// <returns>The rendered <typeparamref name="TComponent"/></returns>
 		public virtual IRenderedComponent<TComponent> RenderComponent<TComponent>(Action<ComponentParameterBuilder<TComponent>> parameterBuilder) where TComponent : IComponent
-		{
-			if (parameterBuilder is null)
-				throw new ArgumentNullException(nameof(parameterBuilder));
-
-			var builder = new ComponentParameterBuilder<TComponent>();
-			parameterBuilder(builder);
-			var renderedFragment = Renderer.RenderComponent<TComponent>(builder.Build());
-			return (IRenderedComponent<TComponent>)renderedFragment;
-		}
+			=> TestRendererExtensions.RenderComponent<TComponent>(Renderer, parameterBuilder);
 	}
 }
diff --git a/tests/bunit.core.tests/Rendering/TestRendererTest.cs b/tests/bunit.core.tests/Rendering/TestRendererTest.cs
index 8a1cdf438..65dbbd4ab 100644
--- a/tests/bunit.core.tests/Rendering/TestRendererTest.cs
+++ b/tests/bunit.core.tests/Rendering/TestRendererTest.cs
@@ -18,7 +18,6 @@
 
 namespace Bunit.Rendering
 {
-
 	public class NoChildNoParams : ComponentBase
 	{
 		public const string MARKUP = "hello world";
@@ -82,15 +81,6 @@ protected override void BuildRenderTree(RenderTreeBuilder builder)
 		}
 	}
 
-	internal static class TestRendererExtensions
-	{
-		public static IRenderedComponent<TComponent> RenderComponent<TComponent>(this ITestRenderer renderer, params ComponentParameter[] parameters)
-			where TComponent : IComponent
-		{
-			return (IRenderedComponent<TComponent>)renderer.RenderComponent<TComponent>(parameters);
-		}
-	}
-
 	public class TestRendererTest
 	{
 		private TestServiceProvider Services { get; }
@@ -99,12 +89,7 @@ public TestRendererTest()
 		{
 			Services = new TestServiceProvider();
 			Services.AddDefaultTestContextServices();
-			Services.AddSingleton<ITestRenderer>(srv =>
-			{
-				var rca = srv.GetRequiredService<IRenderedComponentActivator>();
-				var loggerFactory = srv.GetService<ILoggerFactory>() ?? NullLoggerFactory.Instance;
-				return new TestRenderer(rca, srv, loggerFactory);
-			});
+			Services.AddSingleton<ITestRenderer, TestRenderer>();
 		}
 
 		[Fact(DisplayName = "RenderFragment re-throws exception from component")]

From 29ff6e6d746ee1c5c71d42d50cebcafef68ec69a Mon Sep 17 00:00:00 2001
From: Github Actions <actions@github.com>
Date: Tue, 1 Sep 2020 22:04:45 +0000
Subject: [PATCH 11/11] Automated dotnet-format update

---
 src/bunit.web/Extensions/TestRendererExtensions.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/bunit.web/Extensions/TestRendererExtensions.cs b/src/bunit.web/Extensions/TestRendererExtensions.cs
index f19257c9e..60f7e8174 100644
--- a/src/bunit.web/Extensions/TestRendererExtensions.cs
+++ b/src/bunit.web/Extensions/TestRendererExtensions.cs
@@ -12,8 +12,8 @@ namespace Bunit.Extensions
 	/// Helper methods that make it easier to work directly with a <see cref="ITestRenderer"/>
 	/// in bUnit web.
 	/// </summary>
-    public static class TestRendererExtensions
-    {
+	public static class TestRendererExtensions
+	{
 		/// <summary>
 		/// Renders a <typeparamref name="TComponent"/> with the parameters <paramref name="parameters"/> passed to it.
 		/// </summary>