diff --git a/Directory.Packages.props b/Directory.Packages.props
index 7924fbb3d..773d53d07 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -46,7 +46,7 @@
 		<PackageVersion Include="System.Net.Http" Version="4.3.4"/>
 		<PackageVersion Include="aweXpect" Version="2.33.0"/>
 		<PackageVersion Include="aweXpect.Chronology" Version="1.1.0"/>
-		<PackageVersion Include="aweXpect.Testably" Version="0.13.0"/>
+		<PackageVersion Include="aweXpect.Testably" Version="0.14.0"/>
 		<PackageVersion Include="aweXpect.Mockolate" Version="3.1.0"/>
 		<PackageVersion Include="Mockolate" Version="3.2.0"/>
 		<PackageVersion Include="TUnit.Engine" Version="1.24.0"/>
diff --git a/Tests/Testably.Abstractions.Testing.Tests/FileSystemInitializer/FileSystemInitializerTests.cs b/Tests/Testably.Abstractions.Testing.Tests/FileSystemInitializer/FileSystemInitializerTests.cs
index 88780ed71..847b79e87 100644
--- a/Tests/Testably.Abstractions.Testing.Tests/FileSystemInitializer/FileSystemInitializerTests.cs
+++ b/Tests/Testably.Abstractions.Testing.Tests/FileSystemInitializer/FileSystemInitializerTests.cs
@@ -54,8 +54,7 @@ public async Task With_FileDescription_WithBytes_ShouldCreateFileContent(string
 		sut.With(description);
 
 		await That(fileSystem.Statistics.TotalCount).IsEqualTo(0);
-		await That(fileSystem.File.Exists(name)).IsTrue();
-		await That(fileSystem.File.ReadAllBytes(name)).IsEqualTo(bytes);
+		await That(fileSystem).HasFile(name).WithContent(bytes);
 	}
 
 	[Test]
@@ -70,8 +69,7 @@ public async Task With_FileDescription_WithContent_ShouldCreateFileContent(strin
 		sut.With(description);
 
 		await That(fileSystem.Statistics.TotalCount).IsEqualTo(0);
-		await That(fileSystem.File.Exists(name)).IsTrue();
-		await That(fileSystem.File.ReadAllText(name)).IsEqualTo(content);
+		await That(fileSystem).HasFile(name).WithContent(content);
 	}
 
 	[Test]
@@ -105,8 +103,14 @@ public async Task With_FileDescriptions_ShouldSetIsReadOnlyFlag(bool isReadOnly,
 		sut.With(description);
 
 		await That(fileSystem.Statistics.TotalCount).IsEqualTo(0);
-		await That(fileSystem.File.Exists(name)).IsTrue();
-		await That(fileSystem.FileInfo.New(name).IsReadOnly).IsEqualTo(isReadOnly);
+		if (isReadOnly)
+		{
+			await That(fileSystem).HasFile(name).Which.IsReadOnly();
+		}
+		else
+		{
+			await That(fileSystem).HasFile(name).Which.IsNotReadOnly();
+		}
 	}
 
 	[Test]
@@ -204,8 +208,7 @@ public async Task WithFile_HasStringContent_ShouldWriteFileContent(string path)
 		sut.WithFile(path).Which(f => f.HasStringContent("foo"));
 
 		await That(fileSystem.Statistics.TotalCount).IsEqualTo(0);
-		await That(fileSystem.File.Exists(path)).IsTrue();
-		await That(fileSystem.File.ReadAllText(path)).IsEqualTo("foo");
+		await That(fileSystem).HasFile(path).WithContent("foo");
 	}
 
 	[Test]
diff --git a/Tests/Testably.Abstractions.Testing.Tests/FileSystemInitializerExtensionsTests.cs b/Tests/Testably.Abstractions.Testing.Tests/FileSystemInitializerExtensionsTests.cs
index ee01c6e88..8dd2a41df 100644
--- a/Tests/Testably.Abstractions.Testing.Tests/FileSystemInitializerExtensionsTests.cs
+++ b/Tests/Testably.Abstractions.Testing.Tests/FileSystemInitializerExtensionsTests.cs
@@ -1,5 +1,4 @@
-using aweXpect.Testably;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using Testably.Abstractions.Testing.Initializer;
diff --git a/Tests/Testably.Abstractions.Testing.Tests/TestHelpers/Usings.cs b/Tests/Testably.Abstractions.Testing.Tests/TestHelpers/Usings.cs
index a14f370a0..1075e4ab2 100644
--- a/Tests/Testably.Abstractions.Testing.Tests/TestHelpers/Usings.cs
+++ b/Tests/Testably.Abstractions.Testing.Tests/TestHelpers/Usings.cs
@@ -5,5 +5,6 @@
 global using Test = Testably.Abstractions.Testing.Tests.TestHelpers.Test;
 global using TUnit;
 global using aweXpect;
+global using aweXpect.Testably;
 global using static aweXpect.Expect;
 global using Skip = Testably.Abstractions.TestHelpers.Skip;
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllBytesAsyncTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllBytesAsyncTests.cs
index d489762f9..b46527c7b 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllBytesAsyncTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllBytesAsyncTests.cs
@@ -33,8 +33,7 @@ await FileSystem.File.AppendAllBytesAsync(path, previousBytes,
 		await FileSystem.File.AppendAllBytesAsync(path, bytes,
 			CancellationToken);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo([..previousBytes, ..bytes]);
+		await That(FileSystem).HasFile(path).WithContent([..previousBytes, ..bytes]);
 	}
 
 	[Test]
@@ -61,8 +60,7 @@ public async Task AppendAllBytesAsync_MissingFile_ShouldCreateFile(
 		await FileSystem.File.AppendAllBytesAsync(path, bytes,
 			CancellationToken);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo(bytes);
+		await That(FileSystem).HasFile(path).WithContent(bytes);
 	}
 
 	[Test]
@@ -90,8 +88,7 @@ await FileSystem.File.AppendAllBytesAsync(path, previousBytes,
 		await FileSystem.File.AppendAllBytesAsync(path, bytes.AsMemory(),
 			CancellationToken);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo([..previousBytes, ..bytes]);
+		await That(FileSystem).HasFile(path).WithContent([..previousBytes, ..bytes]);
 	}
 
 	[Test]
@@ -119,8 +116,7 @@ public async Task AppendAllBytesAsync_ReadOnlyMemory_MissingFile_ShouldCreateFil
 		await FileSystem.File.AppendAllBytesAsync(path, bytes.AsMemory(),
 			CancellationToken);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo(bytes);
+		await That(FileSystem).HasFile(path).WithContent(bytes);
 	}
 
 	[Test]
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllBytesTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllBytesTests.cs
index f60f20385..24e11ce78 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllBytesTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllBytesTests.cs
@@ -15,8 +15,7 @@ public async Task AppendAllBytes_ExistingFile_ShouldAppendLinesToFile(
 
 		FileSystem.File.AppendAllBytes(path, bytes);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo([..previousBytes, ..bytes]);
+		await That(FileSystem).HasFile(path).WithContent([..previousBytes, ..bytes]);
 	}
 
 	[Test]
@@ -40,8 +39,7 @@ public async Task AppendAllBytes_MissingFile_ShouldCreateFile(
 	{
 		FileSystem.File.AppendAllBytes(path, bytes);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo(bytes);
+		await That(FileSystem).HasFile(path).WithContent(bytes);
 	}
 
 	[Test]
@@ -84,8 +82,7 @@ public async Task AppendAllBytes_Span_ExistingFile_ShouldAppendLinesToFile(
 
 		FileSystem.File.AppendAllBytes(path, bytes.AsSpan());
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo([..previousBytes, ..bytes]);
+		await That(FileSystem).HasFile(path).WithContent([..previousBytes, ..bytes]);
 	}
 
 	[Test]
@@ -109,8 +106,7 @@ public async Task AppendAllBytes_Span_MissingFile_ShouldCreateFile(
 	{
 		FileSystem.File.AppendAllBytes(path, bytes.AsSpan());
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo(bytes);
+		await That(FileSystem).HasFile(path).WithContent(bytes);
 	}
 
 	[Test]
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllLinesAsyncTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllLinesAsyncTests.cs
index 70f7695ed..95ac8206d 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllLinesAsyncTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllLinesAsyncTests.cs
@@ -69,8 +69,7 @@ await FileSystem.File.AppendAllLinesAsync(path, previousContents,
 		await FileSystem.File.AppendAllLinesAsync(path, contents,
 			CancellationToken);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(expectedContent);
+		await That(FileSystem).HasFile(path).WithContent(expectedContent);
 	}
 
 	[Test]
@@ -100,8 +99,7 @@ public async Task AppendAllLinesAsync_MissingFile_ShouldCreateFile(
 		await FileSystem.File.AppendAllLinesAsync(path, contents,
 			CancellationToken);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(expectedContent);
+		await That(FileSystem).HasFile(path).WithContent(expectedContent);
 	}
 
 	[Test]
@@ -146,8 +144,7 @@ public async Task AppendAllLinesAsync_ShouldEndWithNewline(string path)
 		await FileSystem.File.AppendAllLinesAsync(path, contents,
 			CancellationToken);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(expectedResult);
+		await That(FileSystem).HasFile(path).WithContent(expectedResult);
 	}
 
 	[Test]
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllLinesTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllLinesTests.cs
index 9288814a4..4b4393314 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllLinesTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllLinesTests.cs
@@ -32,8 +32,7 @@ public async Task AppendAllLines_ExistingFile_ShouldAppendLinesToFile(
 
 		FileSystem.File.AppendAllLines(path, contents);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(expectedContent);
+		await That(FileSystem).HasFile(path).WithContent(expectedContent);
 	}
 
 	[Test]
@@ -45,8 +44,7 @@ public async Task AppendAllLines_MissingFile_ShouldCreateFile(
 		                         + Environment.NewLine;
 		FileSystem.File.AppendAllLines(path, contents);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(expectedContent);
+		await That(FileSystem).HasFile(path).WithContent(expectedContent);
 	}
 
 	[Test]
@@ -88,8 +86,7 @@ public async Task AppendAllLines_ShouldEndWithNewline(string path)
 
 		FileSystem.File.AppendAllLines(path, contents);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(expectedResult);
+		await That(FileSystem).HasFile(path).WithContent(expectedResult);
 	}
 
 	[Test]
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllTextAsyncTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllTextAsyncTests.cs
index 4db7731e2..9e255eb29 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllTextAsyncTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllTextAsyncTests.cs
@@ -50,8 +50,7 @@ await FileSystem.File.AppendAllTextAsync(path, previousContents,
 		await FileSystem.File.AppendAllTextAsync(path, contents,
 			CancellationToken);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(previousContents + contents);
+		await That(FileSystem).HasFile(path).WithContent(previousContents + contents);
 	}
 
 	[Test]
@@ -78,8 +77,7 @@ public async Task AppendAllTextAsync_MissingFile_ShouldCreateFile(
 		await FileSystem.File.AppendAllTextAsync(path, contents,
 			CancellationToken);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(contents);
+		await That(FileSystem).HasFile(path).WithContent(contents);
 	}
 
 	[Test]
@@ -91,8 +89,7 @@ public async Task AppendAllTextAsync_ShouldNotEndWithNewline(string path)
 		await FileSystem.File.AppendAllTextAsync(path, contents,
 			CancellationToken);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(contents);
+		await That(FileSystem).HasFile(path).WithContent(contents);
 	}
 
 	[Test]
@@ -183,8 +180,7 @@ await FileSystem.File.AppendAllTextAsync(path, previousContents,
 		await FileSystem.File.AppendAllTextAsync(path, contents.AsMemory(),
 			CancellationToken);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(previousContents + contents);
+		await That(FileSystem).HasFile(path).WithContent(previousContents + contents);
 	}
 
 	[Test]
@@ -212,8 +208,7 @@ public async Task AppendAllTextAsync_ReadOnlyMemory_MissingFile_ShouldCreateFile
 		await FileSystem.File.AppendAllTextAsync(path, contents.AsMemory(),
 			CancellationToken);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(contents);
+		await That(FileSystem).HasFile(path).WithContent(contents);
 	}
 
 	[Test]
@@ -225,8 +220,7 @@ public async Task AppendAllTextAsync_ReadOnlyMemory_ShouldNotEndWithNewline(stri
 		await FileSystem.File.AppendAllTextAsync(path, contents.AsMemory(),
 			CancellationToken);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(contents);
+		await That(FileSystem).HasFile(path).WithContent(contents);
 	}
 
 	[Test]
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllTextTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllTextTests.cs
index f84933a52..06bea43c1 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllTextTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendAllTextTests.cs
@@ -16,8 +16,7 @@ public async Task AppendAllText_ExistingFile_ShouldAppendLinesToFile(
 
 		FileSystem.File.AppendAllText(path, contents);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(previousContents + contents);
+		await That(FileSystem).HasFile(path).WithContent(previousContents + contents);
 	}
 
 	[Test]
@@ -42,8 +41,7 @@ public async Task AppendAllText_MissingFile_ShouldCreateFile(
 	{
 		FileSystem.File.AppendAllText(path, contents);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(contents);
+		await That(FileSystem).HasFile(path).WithContent(contents);
 	}
 
 	[Test]
@@ -55,8 +53,7 @@ public async Task AppendAllText_MissingFile_ShouldCreateFileWithByteOrderMark(
 
 		FileSystem.File.AppendAllText(path, "AA", Encoding.UTF32);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo(expectedBytes);
+		await That(FileSystem).HasFile(path).WithContent(expectedBytes);
 	}
 
 	[Test]
@@ -100,8 +97,7 @@ public async Task AppendAllText_ShouldNotEndWithNewline(string path)
 
 		FileSystem.File.AppendAllText(path, contents);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(contents);
+		await That(FileSystem).HasFile(path).WithContent(contents);
 	}
 
 	[Test]
@@ -175,8 +171,7 @@ public async Task AppendAllText_Span_ExistingFile_ShouldAppendLinesToFile(
 
 		FileSystem.File.AppendAllText(path, contents.AsSpan());
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(previousContents + contents);
+		await That(FileSystem).HasFile(path).WithContent(previousContents + contents);
 	}
 
 	[Test]
@@ -201,8 +196,7 @@ public async Task AppendAllText_Span_MissingFile_ShouldCreateFile(
 	{
 		FileSystem.File.AppendAllText(path, contents.AsSpan());
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(contents);
+		await That(FileSystem).HasFile(path).WithContent(contents);
 	}
 
 	[Test]
@@ -214,8 +208,7 @@ public async Task AppendAllText_Span_MissingFile_ShouldCreateFileWithByteOrderMa
 
 		FileSystem.File.AppendAllText(path, "AA".AsSpan(), Encoding.UTF32);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo(expectedBytes);
+		await That(FileSystem).HasFile(path).WithContent(expectedBytes);
 	}
 
 	[Test]
@@ -259,8 +252,7 @@ public async Task AppendAllText_Span_ShouldNotEndWithNewline(string path)
 
 		FileSystem.File.AppendAllText(path, contents.AsSpan());
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(contents);
+		await That(FileSystem).HasFile(path).WithContent(contents);
 	}
 
 	[Test]
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendTextTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendTextTests.cs
index 1678a3808..c75648189 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendTextTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/File/AppendTextTests.cs
@@ -15,8 +15,7 @@ public async Task AppendText_MissingFile_ShouldCreateFile(
 			stream.Write(appendText);
 		}
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(appendText);
+		await That(FileSystem).HasFile(path).WithContent(appendText);
 	}
 
 	[Test]
@@ -31,7 +30,6 @@ public async Task AppendText_ShouldAddTextToExistingFile(
 			stream.Write(appendText);
 		}
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(contents + appendText);
+		await That(FileSystem).HasFile(path).WithContent(contents + appendText);
 	}
 }
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/File/CopyTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/File/CopyTests.cs
index a033f47b6..092522e2d 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/File/CopyTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/File/CopyTests.cs
@@ -68,10 +68,8 @@ void Act()
 
 		await That(Act).Throws<IOException>().WithHResult(Test.RunsOnWindows ? -2147024816 : 17);
 
-		await That(FileSystem.File.Exists(sourceName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(sourceName)).IsEqualTo(sourceContents);
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(destinationContents);
+		await That(FileSystem).HasFile(sourceName).WithContent(sourceContents);
+		await That(FileSystem).HasFile(destinationName).WithContent(destinationContents);
 	}
 
 #if FEATURE_FILE_MOVETO_OVERWRITE
@@ -88,10 +86,8 @@ public async Task Copy_DestinationExists_WithOverwrite_ShouldOverwriteDestinatio
 
 		FileSystem.File.Copy(sourceName, destinationName, true);
 
-		await That(FileSystem.File.Exists(sourceName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(sourceName)).IsEqualTo(sourceContents);
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(sourceContents);
+		await That(FileSystem).HasFile(sourceName).WithContent(sourceContents);
+		await That(FileSystem).HasFile(destinationName).WithContent(sourceContents);
 	}
 #endif
 
@@ -149,10 +145,8 @@ public async Task Copy_ReadOnly_ShouldCopyFile(
 
 		FileSystem.File.Copy(sourceName, destinationName);
 
-		await That(FileSystem.File.Exists(sourceName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(sourceName)).IsEqualTo(contents);
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(contents);
+		await That(FileSystem).HasFile(sourceName).WithContent(contents);
+		await That(FileSystem).HasFile(destinationName).WithContent(contents);
 		await That(FileSystem.File.GetAttributes(destinationName)).HasFlag(FileAttributes.ReadOnly);
 	}
 
@@ -241,8 +235,7 @@ public async Task Copy_ShouldCloneBinaryContent(
 			binaryWriter.Write("Some text");
 		}
 
-		await That(FileSystem.File.Exists(destination)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(destination)).IsEqualTo(original);
+		await That(FileSystem).HasFile(destination).WithContent(original);
 		await That(FileSystem.File.ReadAllBytes(destination))
 			.IsNotEqualTo(FileSystem.File.ReadAllBytes(source));
 	}
@@ -281,10 +274,8 @@ public async Task Copy_ShouldCopyFileWithContent(
 		TimeSystem.Thread.Sleep(EnsureTimeout);
 
 		FileSystem.File.Copy(sourceName, destinationName);
-		await That(FileSystem.File.Exists(sourceName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(sourceName)).IsEqualTo(contents);
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(contents);
+		await That(FileSystem).HasFile(sourceName).WithContent(contents);
+		await That(FileSystem).HasFile(destinationName).WithContent(contents);
 	}
 
 	[Test]
@@ -309,8 +300,7 @@ public async Task Copy_SourceAccessedWithReadShare_ShouldNotThrow(
 			FileSystem.File.Copy(sourcePath, destinationPath);
 		}
 
-		await That(FileSystem.File.Exists(destinationPath)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationPath)).IsEqualTo(sourceContents);
+		await That(FileSystem).HasFile(destinationPath).WithContent(sourceContents);
 	}
 
 	[Test]
@@ -333,8 +323,7 @@ public async Task Copy_SourceAccessedWithWriteShare_ShouldNotThrowOnLinuxOrMac(
 			FileSystem.File.Copy(sourcePath, destinationPath);
 		}
 
-		await That(FileSystem.File.Exists(destinationPath)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationPath)).IsEqualTo(sourceContents);
+		await That(FileSystem).HasFile(destinationPath).WithContent(sourceContents);
 	}
 
 	[Test]
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/File/CreateTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/File/CreateTests.cs
index 3cddb31ae..444c2fdde 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/File/CreateTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/File/CreateTests.cs
@@ -18,8 +18,7 @@ public async Task Create_ExistingFile_ShouldBeOverwritten(
 			streamWriter.Write(newContent);
 		}
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(newContent);
+		await That(FileSystem).HasFile(path).WithContent(newContent);
 	}
 
 	[Test]
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/File/CreateTextTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/File/CreateTextTests.cs
index 94068c930..a1fe9d045 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/File/CreateTextTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/File/CreateTextTests.cs
@@ -15,8 +15,7 @@ public async Task CreateText_MissingFile_ShouldCreateFile(
 			stream.Write(appendText);
 		}
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(appendText);
+		await That(FileSystem).HasFile(path).WithContent(appendText);
 	}
 
 	[Test]
@@ -31,7 +30,6 @@ public async Task CreateText_ShouldReplaceTextInExistingFile(
 			stream.Write(appendText);
 		}
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(appendText);
+		await That(FileSystem).HasFile(path).WithContent(appendText);
 	}
 }
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/File/MoveTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/File/MoveTests.cs
index a10eb4be9..41f7733a5 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/File/MoveTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/File/MoveTests.cs
@@ -22,8 +22,7 @@ public async Task Move_CaseOnlyChange_ShouldMoveFileWithContent(
 			await That(FileSystem.File.Exists(sourceName)).IsFalse();
 		}
 
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(contents);
+		await That(FileSystem).HasFile(destinationName).WithContent(contents);
 		await That(FileSystem.Directory.GetFiles(".")).HasSingle()
 			.Matching(d => d.Contains(destinationName, StringComparison.Ordinal));
 	}
@@ -64,10 +63,8 @@ void Act()
 
 		await That(Act).Throws<IOException>().WithHResult(Test.RunsOnWindows ? -2147024713 : 17);
 
-		await That(FileSystem.File.Exists(sourceName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(sourceName)).IsEqualTo(sourceContents);
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(destinationContents);
+		await That(FileSystem).HasFile(sourceName).WithContent(sourceContents);
+		await That(FileSystem).HasFile(destinationName).WithContent(destinationContents);
 	}
 
 #if FEATURE_FILE_MOVETO_OVERWRITE
@@ -85,8 +82,7 @@ public async Task Move_DestinationExists_WithOverwrite_ShouldOverwriteDestinatio
 		FileSystem.File.Move(sourceName, destinationName, true);
 
 		await That(FileSystem.File.Exists(sourceName)).IsFalse();
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(sourceContents);
+		await That(FileSystem).HasFile(destinationName).WithContent(sourceContents);
 	}
 #endif
 
@@ -101,8 +97,7 @@ public async Task Move_ReadOnly_ShouldMoveFile(
 		FileSystem.File.Move(sourceName, destinationName);
 
 		await That(FileSystem.File.Exists(sourceName)).IsFalse();
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(contents);
+		await That(FileSystem).HasFile(destinationName).WithContent(contents);
 		await That(FileSystem.File.GetAttributes(destinationName)).HasFlag(FileAttributes.ReadOnly);
 	}
 
@@ -116,8 +111,7 @@ public async Task Move_ShouldMoveFileWithContent(
 		FileSystem.File.Move(sourceName, destinationName);
 
 		await That(FileSystem.File.Exists(sourceName)).IsFalse();
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(contents);
+		await That(FileSystem).HasFile(destinationName).WithContent(contents);
 	}
 
 	[Test]
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/File/ReplaceTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/File/ReplaceTests.cs
index c92c26a98..b5a1d42f0 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/File/ReplaceTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/File/ReplaceTests.cs
@@ -1,4 +1,3 @@
-using aweXpect.Testably;
 using System.IO;
 
 namespace Testably.Abstractions.Tests.FileSystem.File;
@@ -119,11 +118,9 @@ public async Task Replace_ReadOnly_WithIgnoreMetadataError_ShouldReplaceFile(
 		FileSystem.File.Replace(sourceName, destinationName, backupName, true);
 
 		await That(FileSystem.File.Exists(sourceName)).IsFalse();
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEquivalentTo(sourceContents);
+		await That(FileSystem).HasFile(destinationName).WhoseContent(it => it.IsEquivalentTo(sourceContents));
 		await That(FileSystem.File.GetAttributes(destinationName)).HasFlag(FileAttributes.ReadOnly);
-		await That(FileSystem.File.Exists(backupName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(backupName)).IsEquivalentTo(destinationContents);
+		await That(FileSystem).HasFile(backupName).WhoseContent(it => it.IsEquivalentTo(destinationContents));
 	}
 
 	[Test]
@@ -148,11 +145,8 @@ void Act()
 		if (Test.RunsOnWindows)
 		{
 			await That(Act).Throws<UnauthorizedAccessException>().WithHResult(-2147024891);
-			await That(FileSystem.File.Exists(sourceName)).IsTrue();
-			await That(FileSystem.File.ReadAllText(sourceName)).IsEquivalentTo(sourceContents);
-			await That(FileSystem.File.Exists(destinationName)).IsTrue();
-			await That(FileSystem.File.ReadAllText(destinationName))
-				.IsEquivalentTo(destinationContents);
+			await That(FileSystem).HasFile(sourceName).WhoseContent(it => it.IsEquivalentTo(sourceContents));
+			await That(FileSystem).HasFile(destinationName).WhoseContent(it => it.IsEquivalentTo(destinationContents));
 			await That(FileSystem.File.GetAttributes(destinationName))
 				.DoesNotHaveFlag(FileAttributes.ReadOnly);
 			await That(FileSystem.File.Exists(backupName)).IsFalse();
@@ -161,10 +155,8 @@ await That(FileSystem.File.GetAttributes(destinationName))
 		{
 			await That(Act).DoesNotThrow();
 			await That(FileSystem.File.Exists(sourceName)).IsFalse();
-			await That(FileSystem.File.Exists(destinationName)).IsTrue();
-			await That(FileSystem.File.ReadAllText(destinationName)).IsEquivalentTo(sourceContents);
-			await That(FileSystem.File.Exists(backupName)).IsTrue();
-			await That(FileSystem.File.ReadAllText(backupName)).IsEquivalentTo(destinationContents);
+			await That(FileSystem).HasFile(destinationName).WhoseContent(it => it.IsEquivalentTo(sourceContents));
+			await That(FileSystem).HasFile(backupName).WhoseContent(it => it.IsEquivalentTo(destinationContents));
 		}
 	}
 
@@ -183,10 +175,8 @@ public async Task Replace_ShouldReplaceFile(
 		FileSystem.File.Replace(sourceName, destinationName, backupName);
 
 		await That(FileSystem.File.Exists(sourceName)).IsFalse();
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEquivalentTo(sourceContents);
-		await That(FileSystem.File.Exists(backupName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(backupName)).IsEquivalentTo(destinationContents);
+		await That(FileSystem).HasFile(destinationName).WhoseContent(it => it.IsEquivalentTo(sourceContents));
+		await That(FileSystem).HasFile(backupName).WhoseContent(it => it.IsEquivalentTo(destinationContents));
 	}
 
 	[Test]
@@ -266,11 +256,8 @@ void Act()
 		if (Test.RunsOnWindows)
 		{
 			await That(Act).Throws<IOException>().WithHResult(-2147024864);
-			await That(FileSystem.File.Exists(sourceName)).IsTrue();
-			await That(FileSystem.File.ReadAllText(sourceName)).IsEquivalentTo(sourceContents);
-			await That(FileSystem.File.Exists(destinationName)).IsTrue();
-			await That(FileSystem.File.ReadAllText(destinationName))
-				.IsEquivalentTo(destinationContents);
+			await That(FileSystem).HasFile(sourceName).WhoseContent(it => it.IsEquivalentTo(sourceContents));
+			await That(FileSystem).HasFile(destinationName).WhoseContent(it => it.IsEquivalentTo(destinationContents));
 			await That(FileSystem.File.GetAttributes(destinationName))
 				.DoesNotHaveFlag(FileAttributes.ReadOnly);
 			await That(FileSystem.File.Exists(backupName)).IsFalse();
@@ -280,10 +267,8 @@ await That(FileSystem.File.GetAttributes(destinationName))
 			// https://github.com/dotnet/runtime/issues/52700
 			await That(Act).DoesNotThrow();
 			await That(FileSystem.File.Exists(sourceName)).IsFalse();
-			await That(FileSystem.File.Exists(destinationName)).IsTrue();
-			await That(FileSystem.File.ReadAllText(destinationName)).IsEquivalentTo(sourceContents);
-			await That(FileSystem.File.Exists(backupName)).IsTrue();
-			await That(FileSystem.File.ReadAllText(backupName)).IsEquivalentTo(destinationContents);
+			await That(FileSystem).HasFile(destinationName).WhoseContent(it => it.IsEquivalentTo(sourceContents));
+			await That(FileSystem).HasFile(backupName).WhoseContent(it => it.IsEquivalentTo(destinationContents));
 		}
 	}
 
@@ -326,10 +311,8 @@ public async Task Replace_WithExistingBackupFile_ShouldIgnoreBackup(
 		FileSystem.File.Replace(sourceName, destinationName, null);
 
 		await That(FileSystem.File.Exists(sourceName)).IsFalse();
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEquivalentTo(sourceContents);
-		await That(FileSystem.File.Exists(backupName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(backupName)).IsEquivalentTo(backupContents);
+		await That(FileSystem).HasFile(destinationName).WhoseContent(it => it.IsEquivalentTo(sourceContents));
+		await That(FileSystem).HasFile(backupName).WhoseContent(it => it.IsEquivalentTo(backupContents));
 	}
 
 	[Test]
@@ -346,7 +329,6 @@ public async Task Replace_WithoutBackup_ShouldReplaceFile(
 		FileSystem.File.Replace(sourceName, destinationName, null);
 
 		await That(FileSystem.File.Exists(sourceName)).IsFalse();
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEquivalentTo(sourceContents);
+		await That(FileSystem).HasFile(destinationName).WhoseContent(it => it.IsEquivalentTo(sourceContents));
 	}
 }
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/File/WriteAllBytesAsyncTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/File/WriteAllBytesAsyncTests.cs
index aac45a647..0ef8c700d 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/File/WriteAllBytesAsyncTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/File/WriteAllBytesAsyncTests.cs
@@ -33,8 +33,7 @@ public async Task WriteAllBytesAsync_PreviousFile_ShouldOverwriteFileWithBytes(
 
 		await FileSystem.File.WriteAllBytesAsync(path, bytes, CancellationToken);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo(bytes);
+		await That(FileSystem).HasFile(path).WithContent(bytes);
 	}
 
 	[Test]
@@ -44,8 +43,7 @@ public async Task WriteAllBytesAsync_ShouldCreateFileWithBytes(
 	{
 		await FileSystem.File.WriteAllBytesAsync(path, bytes, CancellationToken);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo(bytes);
+		await That(FileSystem).HasFile(path).WithContent(bytes);
 	}
 
 	[Test]
@@ -122,8 +120,7 @@ public async Task WriteAllBytesAsync_ReadOnlyMemory_PreviousFile_ShouldOverwrite
 
 		await FileSystem.File.WriteAllBytesAsync(path, bytes.AsMemory(), CancellationToken);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo(bytes);
+		await That(FileSystem).HasFile(path).WithContent(bytes);
 	}
 
 	[Test]
@@ -133,8 +130,7 @@ public async Task WriteAllBytesAsync_ReadOnlyMemory_ShouldCreateFileWithBytes(
 	{
 		await FileSystem.File.WriteAllBytesAsync(path, bytes.AsMemory(), CancellationToken);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo(bytes);
+		await That(FileSystem).HasFile(path).WithContent(bytes);
 	}
 
 	[Test]
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/File/WriteAllBytesTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/File/WriteAllBytesTests.cs
index 809a2d9aa..edb498f7d 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/File/WriteAllBytesTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/File/WriteAllBytesTests.cs
@@ -15,8 +15,7 @@ public async Task WriteAllBytes_PreviousFile_ShouldOverwriteFileWithBytes(
 
 		FileSystem.File.WriteAllBytes(path, bytes);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo(bytes);
+		await That(FileSystem).HasFile(path).WithContent(bytes);
 	}
 
 	[Test]
@@ -25,8 +24,7 @@ public async Task WriteAllBytes_ShouldCreateFileWithBytes(string path, byte[] by
 	{
 		FileSystem.File.WriteAllBytes(path, bytes);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo(bytes);
+		await That(FileSystem).HasFile(path).WithContent(bytes);
 	}
 
 	[Test]
@@ -88,8 +86,7 @@ public async Task WriteAllBytes_Span_PreviousFile_ShouldOverwriteFileWithBytes(
 
 		FileSystem.File.WriteAllBytes(path, bytes.AsSpan());
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo(bytes);
+		await That(FileSystem).HasFile(path).WithContent(bytes);
 	}
 
 	[Test]
@@ -98,8 +95,7 @@ public async Task WriteAllBytes_Span_ShouldCreateFileWithBytes(string path, byte
 	{
 		FileSystem.File.WriteAllBytes(path, bytes.AsSpan());
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo(bytes);
+		await That(FileSystem).HasFile(path).WithContent(bytes);
 	}
 
 	[Test]
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/File/WriteAllTextTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/File/WriteAllTextTests.cs
index acc5daa77..8623018cd 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/File/WriteAllTextTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/File/WriteAllTextTests.cs
@@ -79,8 +79,7 @@ public async Task WriteAllText_ShouldCreateFileWithByteOrderMark(
 
 		FileSystem.File.WriteAllText(path, "AA", Encoding.UTF32);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo(expectedBytes);
+		await That(FileSystem).HasFile(path).WithContent(expectedBytes);
 	}
 
 	[Test]
@@ -282,8 +281,7 @@ public async Task WriteAllText_Span_ShouldCreateFileWithByteOrderMark(
 
 		FileSystem.File.WriteAllText(path, "AA".AsSpan(), Encoding.UTF32);
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllBytes(path)).IsEqualTo(expectedBytes);
+		await That(FileSystem).HasFile(path).WithContent(expectedBytes);
 	}
 
 	[Test]
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/AppendTextTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/AppendTextTests.cs
index a4446ff3e..c2dd4ee46 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/AppendTextTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/AppendTextTests.cs
@@ -17,8 +17,7 @@ public async Task AppendText_MissingFile_ShouldCreateFile(
 			stream.Write(appendText);
 		}
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(appendText);
+		await That(FileSystem).HasFile(path).WithContent(appendText);
 	}
 
 	[Test]
@@ -34,7 +33,6 @@ public async Task AppendText_ShouldAddTextToExistingFile(
 			stream.Write(appendText);
 		}
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(contents + appendText);
+		await That(FileSystem).HasFile(path).WithContent(contents + appendText);
 	}
 }
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/CopyToTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/CopyToTests.cs
index d97dda21e..cbeaed3d2 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/CopyToTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/CopyToTests.cs
@@ -24,10 +24,8 @@ void Act()
 
 		await That(Act).Throws<IOException>().WithHResult(Test.RunsOnWindows ? -2147024816 : 17);
 		await That(sut.Exists).IsTrue();
-		await That(FileSystem.File.Exists(sourceName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(sourceName)).IsEqualTo(sourceContents);
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(destinationContents);
+		await That(FileSystem).HasFile(sourceName).WithContent(sourceContents);
+		await That(FileSystem).HasFile(destinationName).WithContent(destinationContents);
 	}
 
 #if FEATURE_FILE_MOVETO_OVERWRITE
@@ -49,10 +47,8 @@ public async Task CopyTo_DestinationExists_WithOverwrite_ShouldOverwriteDestinat
 		await That(sut.FullName).IsEqualTo(FileSystem.Path.GetFullPath(sourceName));
 		await That(result.Exists).IsTrue();
 		await That(result.FullName).IsEqualTo(FileSystem.Path.GetFullPath(destinationName));
-		await That(FileSystem.File.Exists(sourceName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(sourceName)).IsEqualTo(sourceContents);
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(sourceContents);
+		await That(FileSystem).HasFile(sourceName).WithContent(sourceContents);
+		await That(FileSystem).HasFile(destinationName).WithContent(sourceContents);
 	}
 #endif
 
@@ -116,10 +112,8 @@ public async Task CopyTo_ShouldCopyFileWithContent(
 		await That(sut.Exists).IsTrue();
 		await That(result.Exists).IsTrue();
 		await That(result.FullName).IsEqualTo(FileSystem.Path.GetFullPath(destinationName));
-		await That(FileSystem.File.Exists(sourceName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(sourceName)).IsEqualTo(contents);
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(contents);
+		await That(FileSystem).HasFile(sourceName).WithContent(contents);
+		await That(FileSystem).HasFile(destinationName).WithContent(contents);
 	}
 
 	[Test]
@@ -192,8 +186,7 @@ public async Task CopyTo_SourceAccessedWithReadShare_ShouldNotThrow(
 			sut.CopyTo(destinationPath);
 		}
 
-		await That(FileSystem.File.Exists(destinationPath)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationPath)).IsEqualTo(sourceContents);
+		await That(FileSystem).HasFile(destinationPath).WithContent(sourceContents);
 	}
 
 	[Test]
@@ -217,8 +210,7 @@ public async Task CopyTo_SourceAccessedWithWriteShare_ShouldNotThrowOnLinuxOrMac
 			sut.CopyTo(destinationPath);
 		}
 
-		await That(FileSystem.File.Exists(destinationPath)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationPath)).IsEqualTo(sourceContents);
+		await That(FileSystem).HasFile(destinationPath).WithContent(sourceContents);
 	}
 
 	[Test]
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/CreateTextTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/CreateTextTests.cs
index d069e9005..c01850a02 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/CreateTextTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/CreateTextTests.cs
@@ -17,8 +17,7 @@ public async Task CreateText_MissingFile_ShouldCreateFile(
 			stream.Write(appendText);
 		}
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(appendText);
+		await That(FileSystem).HasFile(path).WithContent(appendText);
 	}
 
 #if NET8_0_OR_GREATER
@@ -70,7 +69,6 @@ public async Task CreateText_ShouldReplaceTextInExistingFile(
 			stream.Write(appendText);
 		}
 
-		await That(FileSystem.File.Exists(path)).IsTrue();
-		await That(FileSystem.File.ReadAllText(path)).IsEqualTo(appendText);
+		await That(FileSystem).HasFile(path).WithContent(appendText);
 	}
 }
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/MoveToTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/MoveToTests.cs
index f8253d9c2..43e672b90 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/MoveToTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/MoveToTests.cs
@@ -25,10 +25,8 @@ void Act()
 		await That(Act).Throws<IOException>().WithHResult(Test.RunsOnWindows ? -2147024713 : 17);
 
 		await That(sut.Exists).IsTrue();
-		await That(FileSystem.File.Exists(sourceName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(sourceName)).IsEqualTo(sourceContents);
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(destinationContents);
+		await That(FileSystem).HasFile(sourceName).WithContent(sourceContents);
+		await That(FileSystem).HasFile(destinationName).WithContent(destinationContents);
 	}
 
 #if FEATURE_FILE_MOVETO_OVERWRITE
@@ -50,8 +48,7 @@ public async Task MoveTo_DestinationExists_WithOverwrite_ShouldOverwriteDestinat
 		await That(sut.ToString()).IsEqualTo(destinationName);
 		await That(sut.FullName).IsEqualTo(FileSystem.Path.GetFullPath(destinationName));
 		await That(FileSystem.File.Exists(sourceName)).IsFalse();
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(sourceContents);
+		await That(FileSystem).HasFile(destinationName).WithContent(sourceContents);
 	}
 #endif
 
@@ -114,8 +111,7 @@ void Act()
 		await That(Act).Throws<DirectoryNotFoundException>().WithHResult(-2147024893);
 
 		await That(sut.Exists).IsTrue();
-		await That(FileSystem.File.Exists(sourceName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(sourceName)).IsEqualTo(sourceContents);
+		await That(FileSystem).HasFile(sourceName).WithContent(sourceContents);
 		await That(FileSystem.File.Exists(destinationName)).IsFalse();
 	}
 
@@ -131,8 +127,7 @@ public async Task MoveTo_ReadOnly_ShouldMoveFile(
 		sut.MoveTo(destinationName);
 
 		await That(FileSystem.File.Exists(sourceName)).IsFalse();
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(contents);
+		await That(FileSystem).HasFile(destinationName).WithContent(contents);
 		await That(FileSystem.File.GetAttributes(destinationName)).HasFlag(FileAttributes.ReadOnly);
 	}
 
@@ -199,8 +194,7 @@ public async Task MoveTo_ShouldMoveFileWithContent(
 		await That(sut.FullName).IsEqualTo(FileSystem.Path.GetFullPath(destinationName));
 		await That(sut.Exists).IsTrue();
 		await That(FileSystem.File.Exists(sourceName)).IsFalse();
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(contents);
+		await That(FileSystem).HasFile(destinationName).WithContent(contents);
 	}
 
 	[Test]
diff --git a/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/ReplaceTests.cs b/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/ReplaceTests.cs
index 91545c995..e4a01af4f 100644
--- a/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/ReplaceTests.cs
+++ b/Tests/Testably.Abstractions.Tests/FileSystem/FileInfo/ReplaceTests.cs
@@ -1,4 +1,3 @@
-using aweXpect.Testably;
 using System.IO;
 
 namespace Testably.Abstractions.Tests.FileSystem.FileInfo;
@@ -104,8 +103,7 @@ public async Task Replace_ReadOnly_WithIgnoreMetadataError_ShouldReplaceFile(
 		await That(sut.Exists).IsFalse();
 		await That(FileSystem.File.Exists(sourceName)).IsFalse();
 		await That(result.FullName).IsEqualTo(FileSystem.Path.GetFullPath(destinationName));
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(sourceContents);
+		await That(FileSystem).HasFile(destinationName).WithContent(sourceContents);
 		await That(FileSystem.File.GetAttributes(destinationName)).HasFlag(FileAttributes.ReadOnly);
 		await That(FileSystem.File.Exists(backupName)).IsTrue();
 		await That(FileSystem.File.ReadAllText(backupName)).IsEqualTo(destinationContents);
@@ -134,10 +132,8 @@ void Act()
 		if (Test.RunsOnWindows)
 		{
 			await That(Act).Throws<UnauthorizedAccessException>().WithHResult(-2147024891);
-			await That(FileSystem.File.Exists(sourceName)).IsTrue();
-			await That(FileSystem.File.ReadAllText(sourceName)).IsEqualTo(sourceContents);
-			await That(FileSystem.File.Exists(destinationName)).IsTrue();
-			await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(destinationContents);
+			await That(FileSystem).HasFile(sourceName).WithContent(sourceContents);
+			await That(FileSystem).HasFile(destinationName).WithContent(destinationContents);
 			await That(FileSystem.File.GetAttributes(destinationName))
 				.DoesNotHaveFlag(FileAttributes.ReadOnly);
 			await That(FileSystem.File.Exists(backupName)).IsFalse();
@@ -147,10 +143,8 @@ await That(FileSystem.File.GetAttributes(destinationName))
 			await That(Act).DoesNotThrow();
 			await That(sut.Exists).IsFalse();
 			await That(FileSystem.File.Exists(sourceName)).IsFalse();
-			await That(FileSystem.File.Exists(destinationName)).IsTrue();
-			await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(sourceContents);
-			await That(FileSystem.File.Exists(backupName)).IsTrue();
-			await That(FileSystem.File.ReadAllText(backupName)).IsEqualTo(destinationContents);
+			await That(FileSystem).HasFile(destinationName).WithContent(sourceContents);
+			await That(FileSystem).HasFile(backupName).WithContent(destinationContents);
 		}
 	}
 
@@ -272,10 +266,8 @@ public async Task Replace_ShouldReplaceFile(
 		await That(sut.Exists).IsFalse();
 		await That(FileSystem.File.Exists(sourceName)).IsFalse();
 		await That(result.FullName).IsEqualTo(FileSystem.Path.GetFullPath(destinationName));
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(sourceContents);
-		await That(FileSystem.File.Exists(backupName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(backupName)).IsEqualTo(destinationContents);
+		await That(FileSystem).HasFile(destinationName).WithContent(sourceContents);
+		await That(FileSystem).HasFile(backupName).WithContent(destinationContents);
 	}
 
 	[Test]
@@ -355,10 +347,8 @@ void Act()
 		{
 			await That(Act).Throws<IOException>().WithHResult(-2147024864);
 			await That(sut.Exists).IsTrue();
-			await That(FileSystem.File.Exists(sourceName)).IsTrue();
-			await That(FileSystem.File.ReadAllText(sourceName)).IsEqualTo(sourceContents);
-			await That(FileSystem.File.Exists(destinationName)).IsTrue();
-			await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(destinationContents);
+			await That(FileSystem).HasFile(sourceName).WithContent(sourceContents);
+			await That(FileSystem).HasFile(destinationName).WithContent(destinationContents);
 			await That(FileSystem.File.GetAttributes(destinationName))
 				.DoesNotHaveFlag(FileAttributes.ReadOnly);
 			await That(FileSystem.File.Exists(backupName)).IsFalse();
@@ -369,10 +359,8 @@ await That(FileSystem.File.GetAttributes(destinationName))
 			await That(Act).DoesNotThrow();
 			await That(sut.Exists).IsFalse();
 			await That(FileSystem.File.Exists(sourceName)).IsFalse();
-			await That(FileSystem.File.Exists(destinationName)).IsTrue();
-			await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(sourceContents);
-			await That(FileSystem.File.Exists(backupName)).IsTrue();
-			await That(FileSystem.File.ReadAllText(backupName)).IsEqualTo(destinationContents);
+			await That(FileSystem).HasFile(destinationName).WithContent(sourceContents);
+			await That(FileSystem).HasFile(backupName).WithContent(destinationContents);
 		}
 	}
 
@@ -465,10 +453,8 @@ public async Task Replace_WithExistingBackupFile_ShouldIgnoreBackup(
 		await That(sut.Exists).IsFalse();
 		await That(FileSystem.File.Exists(sourceName)).IsFalse();
 		await That(result.FullName).IsEqualTo(FileSystem.Path.GetFullPath(destinationName));
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(sourceContents);
-		await That(FileSystem.File.Exists(backupName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(backupName)).IsEqualTo(backupContents);
+		await That(FileSystem).HasFile(destinationName).WithContent(sourceContents);
+		await That(FileSystem).HasFile(backupName).WithContent(backupContents);
 	}
 
 	[Test]
@@ -488,7 +474,6 @@ public async Task Replace_WithoutBackup_ShouldReplaceFile(
 		await That(sut.Exists).IsFalse();
 		await That(FileSystem.File.Exists(sourceName)).IsFalse();
 		await That(result.FullName).IsEqualTo(FileSystem.Path.GetFullPath(destinationName));
-		await That(FileSystem.File.Exists(destinationName)).IsTrue();
-		await That(FileSystem.File.ReadAllText(destinationName)).IsEqualTo(sourceContents);
+		await That(FileSystem).HasFile(destinationName).WithContent(sourceContents);
 	}
 }
diff --git a/Tests/Testably.Abstractions.Tests/TestHelpers/Usings.cs b/Tests/Testably.Abstractions.Tests/TestHelpers/Usings.cs
index bb22ea218..408976cf5 100644
--- a/Tests/Testably.Abstractions.Tests/TestHelpers/Usings.cs
+++ b/Tests/Testably.Abstractions.Tests/TestHelpers/Usings.cs
@@ -7,6 +7,7 @@
 global using Testably.Abstractions.Tests.TestHelpers;
 global using TUnit;
 global using aweXpect;
+global using aweXpect.Testably;
 global using static aweXpect.Expect;
 global using Skip = Testably.Abstractions.TestHelpers.Skip;
 #if NET48