diff --git a/Source/Testably.Abstractions.FluentAssertions/FileSystemExtensions.cs b/Source/Testably.Abstractions.FluentAssertions/FileSystemExtensions.cs
index d93221f..796268a 100644
--- a/Source/Testably.Abstractions.FluentAssertions/FileSystemExtensions.cs
+++ b/Source/Testably.Abstractions.FluentAssertions/FileSystemExtensions.cs
@@ -1,4 +1,6 @@
-namespace Testably.Abstractions.FluentAssertions;
+using Testably.Abstractions.Testing.Statistics;
+
+namespace Testably.Abstractions.FluentAssertions;
 
 /// <summary>
 ///     Assertion extensions on <see cref="IFileSystem" />.
@@ -32,4 +34,11 @@ public static FileSystemInfoAssertions Should(this IFileSystemInfo? instance)
 	/// </summary>
 	public static FileSystemAssertions Should(this IFileSystem instance)
 		=> new(instance);
+
+	/// <summary>
+	///     Returns a <see cref="StatisticAssertions{TType}" /> object that can be used to
+	///     assert the current <see cref="IStatistics{TType}" />.
+	/// </summary>
+	public static StatisticAssertions<TType> Should<TType>(this IStatistics<TType>? instance)
+		=> new(instance);
 }
diff --git a/Source/Testably.Abstractions.FluentAssertions/StatisticAssertions.cs b/Source/Testably.Abstractions.FluentAssertions/StatisticAssertions.cs
new file mode 100644
index 0000000..cf0b024
--- /dev/null
+++ b/Source/Testably.Abstractions.FluentAssertions/StatisticAssertions.cs
@@ -0,0 +1,51 @@
+using System.Linq;
+using Testably.Abstractions.Testing.Statistics;
+
+namespace Testably.Abstractions.FluentAssertions;
+
+/// <summary>
+///     Assertions on <see cref="IFileInfo" />.
+/// </summary>
+public class StatisticAssertions<TType> :
+	ReferenceTypeAssertions<IStatistics?, StatisticAssertions<TType>>
+{
+	/// <inheritdoc cref="ReferenceTypeAssertions{TSubject,TAssertions}.Identifier" />
+	protected override string Identifier => "statistics";
+
+	internal StatisticAssertions(IStatistics? instance)
+		: base(instance)
+	{
+	}
+
+	/// <summary>
+	///     Returns a <see cref="StatisticPropertyAssertions{TType,TAssertions}" /> object that can be used to assert that the
+	///     property named <paramref name="propertyName" /> was accessed a certain number of times.
+	/// </summary>
+	public StatisticPropertyAssertions<TType, StatisticAssertions<TType>> HaveAccessed(
+		string propertyName)
+	{
+		if (Subject == null)
+		{
+			return new StatisticPropertyAssertions<TType, StatisticAssertions<TType>>(this, propertyName);
+		}
+
+		return new StatisticPropertyAssertions<TType, StatisticAssertions<TType>>(this, propertyName,
+			Subject.Properties.Where(p => p.Name == propertyName));
+	}
+
+	/// <summary>
+	///     Returns a <see cref="StatisticMethodAssertions{TType,TAssertions}" /> object that can be used to assert that the
+	///     method named <paramref name="methodName" /> was called a certain number of times.
+	/// </summary>
+	public StatisticMethodAssertions<TType, StatisticAssertions<TType>> HaveCalled(
+		string methodName)
+	{
+		if (Subject == null)
+		{
+			return new StatisticMethodAssertions<TType, StatisticAssertions<TType>>(this, methodName);
+		}
+
+		return new StatisticMethodAssertions<TType, StatisticAssertions<TType>>(this, methodName,
+			Subject.Methods.Where(m => m.Name == methodName));
+	}
+}
diff --git a/Source/Testably.Abstractions.FluentAssertions/StatisticAssertionsCount.cs b/Source/Testably.Abstractions.FluentAssertions/StatisticAssertionsCount.cs
new file mode 100644
index 0000000..26bb163
--- /dev/null
+++ b/Source/Testably.Abstractions.FluentAssertions/StatisticAssertionsCount.cs
@@ -0,0 +1,242 @@
+namespace Testably.Abstractions.FluentAssertions;
+
+/// <summary>
+///     Assertions on statistics.
+/// </summary>
+public abstract class StatisticAssertionsCount<TType, TAssertions>(TAssertions assertions)
+	where TAssertions : StatisticAssertions<TType>
+{
+	/// <summary>
+	///     Flag indicating if the subject of the assertion is null.
+	/// </summary>
+	protected abstract bool IsSubjectNull { get; }
+
+	/// <summary>
+	///     The name of the statistic.
+	/// </summary>
+	protected abstract string StatisticName { get; }
+
+	/// <summary>
+	///     The type of the statistic.
+	/// </summary>
+	protected abstract string StatisticType { get; }
+
+	/// <summary>
+	///     The verb to interact with the statistic type.
+	/// </summary>
+	protected abstract string StatisticTypeVerb { get; }
+
+	/// <summary>
+	///     Asserts that the number of calls on the filtered methods/properties is at least <paramref name="count" /> times.
+	/// </summary>
+	public AndConstraint<TAssertions> AtLeast(int count,
+		string because = "", params object[] becauseArgs)
+	{
+		int actualCount = GetCount();
+		Execute.Assertion
+			.WithDefaultIdentifier("Statistic")
+			.BecauseOf(because, becauseArgs)
+			.ForCondition(!IsSubjectNull)
+			.FailWith("You can't assert a statistic if it is null.")
+			.Then
+			.ForCondition(actualCount >= count)
+			.FailWith(
+				$"Expected {StatisticType} `{StatisticName}` to be {StatisticTypeVerb} at least {CountToString(count)}{{reason}}, but it was {CountToString(actualCount)}.");
+
+		return new AndConstraint<TAssertions>(assertions);
+	}
+
+	/// <summary>
+	///     Asserts that the number of calls on the filtered methods/properties is at least 1.
+	/// </summary>
+	public AndConstraint<TAssertions> AtLeastOnce(
+		string because = "", params object[] becauseArgs)
+	{
+		int count = GetCount();
+		Execute.Assertion
+			.WithDefaultIdentifier("Statistic")
+			.BecauseOf(because, becauseArgs)
+			.ForCondition(!IsSubjectNull)
+			.FailWith("You can't assert a statistic if it is null.")
+			.Then
+			.ForCondition(count >= 1)
+			.FailWith(
+				$"Expected {StatisticType} `{StatisticName}` to be {StatisticTypeVerb} at least once{{reason}}, but it was {CountToString(count)}.");
+
+		return new AndConstraint<TAssertions>(assertions);
+	}
+
+	/// <summary>
+	///     Asserts that the number of calls on the filtered methods/properties is at least 2.
+	/// </summary>
+	public AndConstraint<TAssertions> AtLeastTwice(
+		string because = "", params object[] becauseArgs)
+	{
+		int count = GetCount();
+		Execute.Assertion
+			.WithDefaultIdentifier("Statistic")
+			.BecauseOf(because, becauseArgs)
+			.ForCondition(!IsSubjectNull)
+			.FailWith("You can't assert a statistic if it is null.")
+			.Then
+			.ForCondition(count >= 2)
+			.FailWith(
+				$"Expected {StatisticType} `{StatisticName}` to be {StatisticTypeVerb} at least twice{{reason}}, but it was {CountToString(count)}.");
+
+		return new AndConstraint<TAssertions>(assertions);
+	}
+
+	/// <summary>
+	///     Asserts that the number of calls on the filtered methods/properties is at most <paramref name="count" /> times.
+	/// </summary>
+	public AndConstraint<TAssertions> AtMost(int count,
+		string because = "", params object[] becauseArgs)
+	{
+		int actualCount = GetCount();
+		Execute.Assertion
+			.WithDefaultIdentifier("Statistic")
+			.BecauseOf(because, becauseArgs)
+			.ForCondition(!IsSubjectNull)
+			.FailWith("You can't assert a statistic if it is null.")
+			.Then
+			.ForCondition(actualCount <= count)
+			.FailWith(
+				$"Expected {StatisticType} `{StatisticName}` to be {StatisticTypeVerb} at most {CountToString(count)}{{reason}}, but it was {CountToString(actualCount)}.");
+
+		return new AndConstraint<TAssertions>(assertions);
+	}
+
+	/// <summary>
+	///     Asserts that the number of calls on the filtered methods/properties is at most 1.
+	/// </summary>
+	public AndConstraint<TAssertions> AtMostOnce(
+		string because = "", params object[] becauseArgs)
+	{
+		int count = GetCount();
+		Execute.Assertion
+			.WithDefaultIdentifier("Statistic")
+			.BecauseOf(because, becauseArgs)
+			.ForCondition(!IsSubjectNull)
+			.FailWith("You can't assert a statistic if it is null.")
+			.Then
+			.ForCondition(count <= 1)
+			.FailWith(
+				$"Expected {StatisticType} `{StatisticName}` to be {StatisticTypeVerb} at most once{{reason}}, but it was {CountToString(count)}.");
+
+		return new AndConstraint<TAssertions>(assertions);
+	}
+
+	/// <summary>
+	///     Asserts that the number of calls on the filtered methods/properties is at most 2.
+	/// </summary>
+	public AndConstraint<TAssertions> AtMostTwice(
+		string because = "", params object[] becauseArgs)
+	{
+		int count = GetCount();
+		Execute.Assertion
+			.WithDefaultIdentifier("Statistic")
+			.BecauseOf(because, becauseArgs)
+			.ForCondition(!IsSubjectNull)
+			.FailWith("You can't assert a statistic if it is null.")
+			.Then
+			.ForCondition(count <= 2)
+			.FailWith(
+				$"Expected {StatisticType} `{StatisticName}` to be {StatisticTypeVerb} at most twice{{reason}}, but it was {CountToString(count)}.");
+
+		return new AndConstraint<TAssertions>(assertions);
+	}
+
+	/// <summary>
+	///     Asserts that the number of calls on the filtered methods/properties is exactly <paramref name="count" /> times.
+	/// </summary>
+	public AndConstraint<TAssertions> Exactly(int count,
+		string because = "", params object[] becauseArgs)
+	{
+		int actualCount = GetCount();
+		Execute.Assertion
+			.WithDefaultIdentifier("Statistic")
+			.BecauseOf(because, becauseArgs)
+			.ForCondition(!IsSubjectNull)
+			.FailWith("You can't assert a statistic if it is null.")
+			.Then
+			.ForCondition(actualCount == count)
+			.FailWith(
+				$"Expected {StatisticType} `{StatisticName}` to be {StatisticTypeVerb} {CountToString(count)}{{reason}}, but it was {CountToString(actualCount)}.");
+
+		return new AndConstraint<TAssertions>(assertions);
+	}
+
+	/// <summary>
+	///     Asserts that the number of calls on the filtered methods/properties is 0 (zero).
+	/// </summary>
+	public AndConstraint<TAssertions> Never(
+		string because = "", params object[] becauseArgs)
+	{
+		int count = GetCount();
+		Execute.Assertion
+			.WithDefaultIdentifier("Statistic")
+			.BecauseOf(because, becauseArgs)
+			.ForCondition(!IsSubjectNull)
+			.FailWith("You can't assert a statistic if it is null.")
+			.Then
+			.ForCondition(count == 0)
+			.FailWith(
+				$"Expected {StatisticType} `{StatisticName}` to never be {StatisticTypeVerb}{{reason}}, but it was {CountToString(count)}.");
+
+		return new AndConstraint<TAssertions>(assertions);
+	}
+
+	/// <summary>
+	///     Asserts that the number of calls on the filtered methods/properties is 1.
+	/// </summary>
+	public AndConstraint<TAssertions> Once(
+		string because = "", params object[] becauseArgs)
+	{
+		int count = GetCount();
+		Execute.Assertion
+			.WithDefaultIdentifier("Statistic")
+			.BecauseOf(because, becauseArgs)
+			.ForCondition(!IsSubjectNull)
+			.FailWith("You can't assert a statistic if it is null.")
+			.Then
+			.ForCondition(count == 1)
+			.FailWith(
+				$"Expected {StatisticType} `{StatisticName}` to be {StatisticTypeVerb} once{{reason}}, but it was {CountToString(count)}.");
+
+		return new AndConstraint<TAssertions>(assertions);
+	}
+
+	/// <summary>
+	///     Asserts that the number of calls on the filtered methods/properties is 2.
+	/// </summary>
+	public AndConstraint<TAssertions> Twice(
+		string because = "", params object[] becauseArgs)
+	{
+		int count = GetCount();
+		Execute.Assertion
+			.WithDefaultIdentifier("Statistic")
+			.BecauseOf(because, becauseArgs)
+			.ForCondition(!IsSubjectNull)
+			.FailWith("You can't assert a statistic if it is null.")
+			.Then
+			.ForCondition(count == 2)
+			.FailWith(
+				$"Expected {StatisticType} `{StatisticName}` to be {StatisticTypeVerb} twice{{reason}}, but it was {CountToString(count)}.");
+
+		return new AndConstraint<TAssertions>(assertions);
+	}
+
+	/// <summary>
+	///     Get the count of matching statistic values.
+	/// </summary>
+	protected abstract int GetCount();
+
+	private static string CountToString(int count)
+		=> count switch
+		{
+			0 => "never",
+			1 => "once",
+			2 => "twice",
+			_ => $"{count} times"
+		};
+}
diff --git a/Source/Testably.Abstractions.FluentAssertions/StatisticMethodAssertions.cs b/Source/Testably.Abstractions.FluentAssertions/StatisticMethodAssertions.cs
new file mode 100644
index 0000000..095e2ae
--- /dev/null
+++ b/Source/Testably.Abstractions.FluentAssertions/StatisticMethodAssertions.cs
@@ -0,0 +1,116 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Testably.Abstractions.Testing.Statistics;
+
+namespace Testably.Abstractions.FluentAssertions;
+
+/// <summary>
+///     Assertions on method statistics.
+/// </summary>
+public class StatisticMethodAssertions<TType, TAssertions>
+	: StatisticAssertionsCount<TType, TAssertions>
+	where TAssertions : StatisticAssertions<TType>
+{
+	/// <inheritdoc cref="StatisticAssertionsCount{TType, TAssertions}.IsSubjectNull" />
+	protected override bool IsSubjectNull { get; }
+
+	/// <inheritdoc cref="StatisticAssertionsCount{TType, TAssertions}.StatisticName" />
+	protected override string StatisticName { get; }
+
+	/// <inheritdoc cref="StatisticAssertionsCount{TType, TAssertions}.StatisticType" />
+	protected override string StatisticType => "method";
+
+	/// <inheritdoc cref="StatisticAssertionsCount{TType, TAssertions}.StatisticTypeVerb" />
+	protected override string StatisticTypeVerb => "called";
+
+	private readonly TAssertions _assertions;
+
+	private readonly IEnumerable<MethodStatistic> _methods;
+
+	internal StatisticMethodAssertions(TAssertions assertions, string methodName)
+		: base(assertions)
+	{
+		_assertions = assertions;
+		IsSubjectNull = true;
+		StatisticName = methodName;
+		_methods = Array.Empty<MethodStatistic>();
+	}
+
+	internal StatisticMethodAssertions(TAssertions assertions, string methodName,
+		IEnumerable<MethodStatistic> methods)
+		: base(assertions)
+	{
+		IsSubjectNull = false;
+		StatisticName = methodName;
+		_assertions = assertions;
+		_methods = methods;
+	}
+
+	/// <summary>
+	///     Filters for methods whose first parameter equals <paramref name="parameterValue" />.
+	/// </summary>
+	public StatisticMethodAssertions<TType, TAssertions> WithFirstParameter<TParameter>(
+		TParameter parameterValue)
+		=> WithParameterAt<TParameter>(0,
+			p => p is null ? parameterValue is null : p.Equals(parameterValue));
+
+	/// <summary>
+	///     Filters for methods whose first parameter matches the <paramref name="predicate" />.
+	/// </summary>
+	public StatisticMethodAssertions<TType, TAssertions> WithFirstParameter<TParameter>(
+		Func<TParameter, bool> predicate)
+		=> WithParameterAt(0, predicate);
+
+	/// <summary>
+	///     Filters for methods whose parameter at the zero-based <paramref name="index" /> equals
+	///     <paramref name="parameterValue" />.
+	/// </summary>
+	public StatisticMethodAssertions<TType, TAssertions> WithParameterAt<TParameter>(int index,
+		TParameter parameterValue)
+		=> WithParameterAt<TParameter>(index,
+			p => p is null ? parameterValue is null : p.Equals(parameterValue));
+
+	/// <summary>
+	///     Filters for methods whose parameter at the zero-based <paramref name="index" />
+	///     matches the <paramref name="predicate" />.
+	/// </summary>
+	public StatisticMethodAssertions<TType, TAssertions> WithParameterAt<TParameter>(int index,
+		Func<TParameter, bool> predicate)
+		=> new(_assertions, StatisticName,
+			_methods.Where(p => p.Parameters[index].Is(predicate)));
+
+	/// <summary>
+	///     Filters for methods whose second parameter equals <paramref name="parameterValue" />.
+	/// </summary>
+	public StatisticMethodAssertions<TType, TAssertions> WithSecondParameter<TParameter>(
+		TParameter parameterValue)
+		=> WithParameterAt<TParameter>(1,
+			p => p is null ? parameterValue is null : p.Equals(parameterValue));
+
+	/// <summary>
+	///     Filters for methods whose second parameter matches the <paramref name="predicate" />.
+	/// </summary>
+	public StatisticMethodAssertions<TType, TAssertions> WithSecondParameter<TParameter>(
+		Func<TParameter, bool> predicate)
+		=> WithParameterAt(1, predicate);
+
+	/// <summary>
+	///     Filters for methods whose third parameter equals <paramref name="parameterValue" />.
+	/// </summary>
+	public StatisticMethodAssertions<TType, TAssertions> WithThirdParameter<TParameter>(
+		TParameter parameterValue)
+		=> WithParameterAt<TParameter>(2,
+			p => p is null ? parameterValue is null : p.Equals(parameterValue));
+
+	/// <summary>
+	///     Filters for methods whose third parameter matches the <paramref name="predicate" />.
+	/// </summary>
+	public StatisticMethodAssertions<TType, TAssertions> WithThirdParameter<TParameter>(
+		Func<TParameter, bool> predicate)
+		=> WithParameterAt(2, predicate);
+
+	/// <inheritdoc cref="StatisticAssertionsCount{TType, TAssertions}.GetCount()" />
+	protected override int GetCount()
+		=> _methods.Count();
+}
diff --git a/Source/Testably.Abstractions.FluentAssertions/StatisticPropertyAssertions.cs b/Source/Testably.Abstractions.FluentAssertions/StatisticPropertyAssertions.cs
new file mode 100644
index 0000000..96813d5
--- /dev/null
+++ b/Source/Testably.Abstractions.FluentAssertions/StatisticPropertyAssertions.cs
@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Testably.Abstractions.Testing.Statistics;
+
+namespace Testably.Abstractions.FluentAssertions;
+
+/// <summary>
+///     Assertions on property statistics.
+/// </summary>
+public class StatisticPropertyAssertions<TType, TAssertions>
+	: StatisticAssertionsCount<TType, TAssertions>
+	where TAssertions : StatisticAssertions<TType>
+{
+	/// <inheritdoc cref="StatisticAssertionsCount{TType, TAssertions}.IsSubjectNull" />
+	protected override bool IsSubjectNull { get; }
+
+	/// <inheritdoc cref="StatisticAssertionsCount{TType, TAssertions}.StatisticName" />
+	protected override string StatisticName { get; }
+
+	/// <inheritdoc cref="StatisticAssertionsCount{TType, TAssertions}.StatisticType" />
+	protected override string StatisticType => "property";
+
+	/// <inheritdoc cref="StatisticAssertionsCount{TType, TAssertions}.StatisticTypeVerb" />
+	protected override string StatisticTypeVerb => "accessed";
+
+	private readonly IEnumerable<PropertyStatistic> _properties;
+
+	internal StatisticPropertyAssertions(TAssertions assertions, string propertyName)
+		: base(assertions)
+	{
+		IsSubjectNull = true;
+		StatisticName = propertyName;
+		_properties = Array.Empty<PropertyStatistic>();
+	}
+
+	internal StatisticPropertyAssertions(TAssertions assertions, string propertyName,
+		IEnumerable<PropertyStatistic> properties)
+		: base(assertions)
+	{
+		IsSubjectNull = false;
+		StatisticName = propertyName;
+		_properties = properties;
+	}
+
+	/// <inheritdoc cref="StatisticAssertionsCount{TType, TAssertions}.GetCount()" />
+	protected override int GetCount()
+		=> _properties.Count();
+}
diff --git a/Source/Testably.Abstractions.FluentAssertions/Testably.Abstractions.FluentAssertions.csproj b/Source/Testably.Abstractions.FluentAssertions/Testably.Abstractions.FluentAssertions.csproj
index 502e5a5..ece9d1f 100644
--- a/Source/Testably.Abstractions.FluentAssertions/Testably.Abstractions.FluentAssertions.csproj
+++ b/Source/Testably.Abstractions.FluentAssertions/Testably.Abstractions.FluentAssertions.csproj
@@ -14,7 +14,7 @@
 
 	<ItemGroup>
 		<PackageReference Include="FluentAssertions" />
-		<PackageReference Include="Testably.Abstractions.Interface" />
+		<PackageReference Include="Testably.Abstractions.Testing" />
 	</ItemGroup>
 
 </Project>
diff --git a/Tests/Testably.Abstractions.FluentAssertions.Tests/StatisticAssertionsCountTests.cs b/Tests/Testably.Abstractions.FluentAssertions.Tests/StatisticAssertionsCountTests.cs
new file mode 100644
index 0000000..9e697d3
--- /dev/null
+++ b/Tests/Testably.Abstractions.FluentAssertions.Tests/StatisticAssertionsCountTests.cs
@@ -0,0 +1,428 @@
+using AutoFixture.Xunit2;
+using FluentAssertions;
+using System;
+using System.IO.Abstractions;
+using Testably.Abstractions.Testing;
+using Testably.Abstractions.Testing.Statistics;
+using Xunit;
+
+namespace Testably.Abstractions.FluentAssertions.Tests;
+
+public class StatisticAssertionsCountTests
+{
+	[Theory]
+	[InlineAutoData(2, 2)]
+	[InlineAutoData(4, 3)]
+	[InlineAutoData(5, 5)]
+	[InlineAutoData(6, 0)]
+	public void AtLeast_WhenCalledEnough_ShouldNotThrow(int callCount, int expectedCount)
+	{
+		MockFileSystem fileSystem = new();
+		for (int i = 0; i < callCount; i++)
+		{
+			fileSystem.File.WriteAllText($"foo-{i}", "bar");
+		}
+
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText)).AtLeast(expectedCount);
+	}
+
+	[Theory]
+	[InlineAutoData(0, "never", 1, "once")]
+	[InlineAutoData(0, "never", 8, "8 times")]
+	[InlineAutoData(5, "5 times", 6, "6 times")]
+	public void AtLeast_WhenCalledLess_ShouldThrow(
+		int actualCount, string actualText, int expectedCount, string expectedText,
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		for (int i = 0; i < actualCount; i++)
+		{
+			fileSystem.File.WriteAllText($"foo-{i}", "bar");
+		}
+
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText)).AtLeast(expectedCount, because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to be called at least {expectedText} {because}, but it was {actualText}.");
+	}
+
+	[Theory]
+	[InlineAutoData(1)]
+	[InlineAutoData(2)]
+	[InlineAutoData(3)]
+	public void AtLeastOnce_WhenCalledAtLeastOnce_ShouldNotThrow(int callCount)
+	{
+		MockFileSystem fileSystem = new();
+		for (int i = 0; i < callCount; i++)
+		{
+			fileSystem.File.WriteAllText($"foo-{i}", "bar");
+		}
+
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText)).AtLeastOnce();
+	}
+
+	[Theory]
+	[InlineAutoData(0, "never")]
+	public void AtLeastOnce_WhenCalledLessThanOnce_ShouldThrow(
+		int callCount, string text,
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		for (int i = 0; i < callCount; i++)
+		{
+			fileSystem.File.WriteAllText($"foo-{i}", "bar");
+		}
+
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText)).AtLeastOnce(because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to be called at least once {because}, but it was {text}.");
+	}
+
+	[Theory]
+	[InlineAutoData(2)]
+	[InlineAutoData(3)]
+	public void AtLeastTwice_WhenCalledAtLeastTwice_ShouldNotThrow(int callCount)
+	{
+		MockFileSystem fileSystem = new();
+		for (int i = 0; i < callCount; i++)
+		{
+			fileSystem.File.WriteAllText($"foo-{i}", "bar");
+		}
+
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText)).AtLeastTwice();
+	}
+
+	[Theory]
+	[InlineAutoData(0, "never")]
+	[InlineAutoData(1, "once")]
+	public void AtLeastTwice_WhenCalledLessThanTwice_ShouldThrow(
+		int callCount, string text,
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		for (int i = 0; i < callCount; i++)
+		{
+			fileSystem.File.WriteAllText($"foo-{i}", "bar");
+		}
+
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText)).AtLeastTwice(because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to be called at least twice {because}, but it was {text}.");
+	}
+
+	[Theory]
+	[InlineAutoData(2, 2)]
+	[InlineAutoData(3, 4)]
+	[InlineAutoData(5, 5)]
+	[InlineAutoData(0, 6)]
+	public void AtMost_WhenCalledEnough_ShouldNotThrow(int callCount, int expectedCount)
+	{
+		MockFileSystem fileSystem = new();
+		for (int i = 0; i < callCount; i++)
+		{
+			fileSystem.File.WriteAllText($"foo-{i}", "bar");
+		}
+
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText)).AtMost(expectedCount);
+	}
+
+	[Theory]
+	[InlineAutoData(1, "once", 0, "never")]
+	[InlineAutoData(8, "8 times", 0, "never")]
+	[InlineAutoData(6, "6 times", 5, "5 times")]
+	public void AtMost_WhenCalledLess_ShouldThrow(
+		int actualCount, string actualText, int expectedCount, string expectedText,
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		for (int i = 0; i < actualCount; i++)
+		{
+			fileSystem.File.WriteAllText($"foo-{i}", "bar");
+		}
+
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText)).AtMost(expectedCount, because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to be called at most {expectedText} {because}, but it was {actualText}.");
+	}
+
+	[Theory]
+	[InlineAutoData(0)]
+	[InlineAutoData(1)]
+	public void AtMostOnce_WhenCalledAtMostOnce_ShouldNotThrow(int callCount)
+	{
+		MockFileSystem fileSystem = new();
+		for (int i = 0; i < callCount; i++)
+		{
+			fileSystem.File.WriteAllText($"foo-{i}", "bar");
+		}
+
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText)).AtMostOnce();
+	}
+
+	[Theory]
+	[InlineAutoData(2, "twice")]
+	[InlineAutoData(3, "3 times")]
+	public void AtMostOnce_WhenCalledMoreThanOnce_ShouldThrow(
+		int callCount, string text,
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		for (int i = 0; i < callCount; i++)
+		{
+			fileSystem.File.WriteAllText($"foo-{i}", "bar");
+		}
+
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText)).AtMostOnce(because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to be called at most once {because}, but it was {text}.");
+	}
+
+	[Theory]
+	[InlineAutoData(0)]
+	[InlineAutoData(1)]
+	[InlineAutoData(2)]
+	public void AtMostTwice_WhenCalledAtMostTwice_ShouldNotThrow(int callCount)
+	{
+		MockFileSystem fileSystem = new();
+		for (int i = 0; i < callCount; i++)
+		{
+			fileSystem.File.WriteAllText($"foo-{i}", "bar");
+		}
+
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText)).AtMostTwice();
+	}
+
+	[Theory]
+	[InlineAutoData(3, "3 times")]
+	public void AtMostTwice_WhenCalledMoreThanTwice_ShouldThrow(
+		int callCount, string text,
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		for (int i = 0; i < callCount; i++)
+		{
+			fileSystem.File.WriteAllText($"foo-{i}", "bar");
+		}
+
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText)).AtMostTwice(because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to be called at most twice {because}, but it was {text}.");
+	}
+
+	[Theory]
+	[InlineAutoData(0)]
+	[InlineAutoData(1)]
+	[InlineAutoData(2)]
+	[InlineAutoData(3)]
+	[AutoData]
+	public void Exactly_WhenCalledCorrectTimes_ShouldNotThrow(int count)
+	{
+		MockFileSystem fileSystem = new();
+		for (int i = 0; i < count; i++)
+		{
+			fileSystem.File.WriteAllText($"foo-{i}", "bar");
+		}
+
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText)).Exactly(count);
+	}
+
+	[Theory]
+	[InlineAutoData(0, "never", 1, "once")]
+	[InlineAutoData(1, "once", 0, "never")]
+	[InlineAutoData(5, "5 times", 6, "6 times")]
+	[InlineAutoData(8, "8 times", 7, "7 times")]
+	public void Exactly_WhenCalledDifferentTimes_ShouldThrow(
+		int actualCount, string actualText, int expectedCount, string expectedText,
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		for (int i = 0; i < actualCount; i++)
+		{
+			fileSystem.File.WriteAllText($"foo-{i}", "bar");
+		}
+
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText)).Exactly(expectedCount, because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to be called {expectedText} {because}, but it was {actualText}.");
+	}
+
+	[Theory]
+	[InlineAutoData(1, "once")]
+	[InlineAutoData(2, "twice")]
+	[InlineAutoData(3, "3 times")]
+	public void Never_WhenCalled_ShouldThrow(
+		int callCount, string text,
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		for (int i = 0; i < callCount; i++)
+		{
+			fileSystem.File.WriteAllText($"foo-{i}", "bar");
+		}
+
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText)).Never(because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to never be called {because}, but it was {text}.");
+	}
+
+	[Fact]
+	public void Never_WhenNotCalled_ShouldNotThrow()
+	{
+		MockFileSystem fileSystem = new();
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText)).Never();
+	}
+
+	[Theory]
+	[InlineAutoData(0, "never")]
+	[InlineAutoData(2, "twice")]
+	[InlineAutoData(3, "3 times")]
+	public void Once_WhenCalled_ShouldThrow(
+		int callCount, string text,
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		for (int i = 0; i < callCount; i++)
+		{
+			fileSystem.File.WriteAllText($"foo-{i}", "bar");
+		}
+
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText)).Once(because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to be called once {because}, but it was {text}.");
+	}
+
+	[Fact]
+	public void Once_WhenCalledOnce_ShouldNotThrow()
+	{
+		MockFileSystem fileSystem = new();
+		fileSystem.File.WriteAllText("foo", "bar");
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText)).Once();
+	}
+
+	[Theory]
+	[InlineAutoData(0, "never")]
+	[InlineAutoData(1, "once")]
+	[InlineAutoData(3, "3 times")]
+	public void Twice_WhenCalled_ShouldThrow(
+		int callCount, string text,
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		for (int i = 0; i < callCount; i++)
+		{
+			fileSystem.File.WriteAllText($"foo-{i}", "bar");
+		}
+
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText)).Twice(because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to be called twice {because}, but it was {text}.");
+	}
+
+	[Fact]
+	public void Twice_WhenCalledTwice_ShouldNotThrow()
+	{
+		MockFileSystem fileSystem = new();
+		fileSystem.File.WriteAllText("foo-1", "bar");
+		fileSystem.File.WriteAllText("foo-2", "bar");
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText)).Twice();
+	}
+}
diff --git a/Tests/Testably.Abstractions.FluentAssertions.Tests/StatisticMethodAssertionsTests.cs b/Tests/Testably.Abstractions.FluentAssertions.Tests/StatisticMethodAssertionsTests.cs
new file mode 100644
index 0000000..b5d5120
--- /dev/null
+++ b/Tests/Testably.Abstractions.FluentAssertions.Tests/StatisticMethodAssertionsTests.cs
@@ -0,0 +1,280 @@
+using AutoFixture.Xunit2;
+using FluentAssertions;
+using System;
+using System.IO.Abstractions;
+using System.Text;
+using Testably.Abstractions.Testing;
+using Testably.Abstractions.Testing.Statistics;
+using Xunit;
+
+namespace Testably.Abstractions.FluentAssertions.Tests;
+
+public class StatisticMethodAssertionsTests
+{
+	[Theory]
+	[AutoData]
+	public void HaveCalled_Never_WhenCalled_ShouldThrow(
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		fileSystem.File.WriteAllText("foo", "bar");
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText)).Never(because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to never be called {because}, but it was once.");
+	}
+
+	[Fact]
+	public void HaveCalled_Never_WhenNotCalled_ShouldNotThrow()
+	{
+		MockFileSystem fileSystem = new();
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText)).Never();
+	}
+
+	[Theory]
+	[AutoData]
+	public void WithFirstParameter_WithPredicate_Never_WhenCalled_ShouldThrow(
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		fileSystem.File.WriteAllText("foo", "bar");
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText))
+				.WithFirstParameter<string>(p => p == "foo")
+				.Never(because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to never be called {because}, but it was once.");
+	}
+
+	[Fact]
+	public void WithFirstParameter_WithPredicate_Never_WhenNotCalled_ShouldNotThrow()
+	{
+		MockFileSystem fileSystem = new();
+		fileSystem.File.WriteAllText("foo", "bar");
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText))
+			.WithFirstParameter<string>(p => p == "bar")
+			.Never();
+	}
+
+	[Theory]
+	[AutoData]
+	public void WithFirstParameter_WithValue_Never_WhenCalled_ShouldThrow(
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		fileSystem.File.WriteAllText("foo", "bar");
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText))
+				.WithFirstParameter("foo")
+				.Never(because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to never be called {because}, but it was once.");
+	}
+
+	[Fact]
+	public void WithFirstParameter_WithValue_Never_WhenNotCalled_ShouldNotThrow()
+	{
+		MockFileSystem fileSystem = new();
+		fileSystem.File.WriteAllText("foo", "bar");
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText))
+			.WithFirstParameter("bar")
+			.Never();
+	}
+
+	[Theory]
+	[AutoData]
+	public void WithParameterAt_WithPredicate_Never_WhenCalled_ShouldThrow(
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		fileSystem.File.WriteAllText("foo", "bar");
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText))
+				.WithParameterAt<string>(0, p => p == "foo")
+				.Never(because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to never be called {because}, but it was once.");
+	}
+
+	[Fact]
+	public void WithParameterAt_WithPredicate_Never_WhenNotCalled_ShouldNotThrow()
+	{
+		MockFileSystem fileSystem = new();
+		fileSystem.File.WriteAllText("foo", "bar");
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText))
+			.WithParameterAt<string>(0, p => p == "bar")
+			.Never();
+	}
+
+	[Theory]
+	[AutoData]
+	public void WithParameterAt_WithValue_Never_WhenCalled_ShouldThrow(
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		fileSystem.File.WriteAllText("foo", "bar");
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText))
+				.WithParameterAt(0, "foo")
+				.Never(because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to never be called {because}, but it was once.");
+	}
+
+	[Fact]
+	public void WithParameterAt_WithValue_Never_WhenNotCalled_ShouldNotThrow()
+	{
+		MockFileSystem fileSystem = new();
+		fileSystem.File.WriteAllText("foo", "bar");
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText))
+			.WithParameterAt(0, "bar")
+			.Never();
+	}
+
+	[Theory]
+	[AutoData]
+	public void WithSecondParameter_WithPredicate_Never_WhenCalled_ShouldThrow(
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		fileSystem.File.WriteAllText("foo", "bar");
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText))
+				.WithSecondParameter<string>(p => p == "bar")
+				.Never(because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to never be called {because}, but it was once.");
+	}
+
+	[Fact]
+	public void WithSecondParameter_WithPredicate_Never_WhenNotCalled_ShouldNotThrow()
+	{
+		MockFileSystem fileSystem = new();
+		fileSystem.File.WriteAllText("foo", "bar");
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText))
+			.WithSecondParameter<string>(p => p == "foo")
+			.Never();
+	}
+
+	[Theory]
+	[AutoData]
+	public void WithSecondParameter_WithValue_Never_WhenCalled_ShouldThrow(
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		fileSystem.File.WriteAllText("foo", "bar");
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText))
+				.WithSecondParameter("bar")
+				.Never(because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to never be called {because}, but it was once.");
+	}
+
+	[Fact]
+	public void WithSecondParameter_WithValue_Never_WhenNotCalled_ShouldNotThrow()
+	{
+		MockFileSystem fileSystem = new();
+		fileSystem.File.WriteAllText("foo", "bar");
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText))
+			.WithSecondParameter("foo")
+			.Never();
+	}
+
+	[Theory]
+	[AutoData]
+	public void WithThirdParameter_WithValue_Never_WhenCalled_ShouldThrow(
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		fileSystem.File.WriteAllText("foo", "bar", Encoding.UTF8);
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveCalled(nameof(IFile.WriteAllText))
+				.WithThirdParameter(Encoding.UTF8)
+				.Never(because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected method `WriteAllText` to never be called {because}, but it was once.");
+	}
+
+	[Fact]
+	public void WithThirdParameter_WithValue_Never_WhenNotCalled_ShouldNotThrow()
+	{
+		MockFileSystem fileSystem = new();
+		fileSystem.File.WriteAllText("foo", "bar", Encoding.UTF8);
+		IStatistics<IFile> sut = fileSystem.Statistics.File;
+
+		sut.Should().HaveCalled(nameof(IFile.WriteAllText))
+			.WithThirdParameter(Encoding.ASCII)
+			.Never();
+	}
+}
diff --git a/Tests/Testably.Abstractions.FluentAssertions.Tests/StatisticPropertyAssertionsTests.cs b/Tests/Testably.Abstractions.FluentAssertions.Tests/StatisticPropertyAssertionsTests.cs
new file mode 100644
index 0000000..d7f7675
--- /dev/null
+++ b/Tests/Testably.Abstractions.FluentAssertions.Tests/StatisticPropertyAssertionsTests.cs
@@ -0,0 +1,41 @@
+using AutoFixture.Xunit2;
+using FluentAssertions;
+using System;
+using System.IO.Abstractions;
+using Testably.Abstractions.Testing;
+using Testably.Abstractions.Testing.Statistics;
+using Xunit;
+
+namespace Testably.Abstractions.FluentAssertions.Tests;
+
+public class StatisticPropertyAssertionsTests
+{
+	[Theory]
+	[AutoData]
+	public void HaveAccessed_Never_WhenAccessed_ShouldThrow(
+		string because)
+	{
+		MockFileSystem fileSystem = new();
+		_ = fileSystem.Path.DirectorySeparatorChar;
+		IStatistics<IPath> sut = fileSystem.Statistics.Path;
+
+		Exception? exception = Record.Exception(() =>
+		{
+			sut.Should().HaveAccessed(nameof(IPath.DirectorySeparatorChar)).Never(because);
+		});
+
+		exception.Should().NotBeNull();
+		exception!.Message.Should()
+			.Be(
+				$"Expected property `DirectorySeparatorChar` to never be accessed {because}, but it was once.");
+	}
+
+	[Fact]
+	public void HaveAccessed_Never_WhenNotAccessed_ShouldNotThrow()
+	{
+		MockFileSystem fileSystem = new();
+		IStatistics<IPath> sut = fileSystem.Statistics.Path;
+
+		sut.Should().HaveAccessed(nameof(IPath.DirectorySeparatorChar)).Never();
+	}
+}