diff --git a/Source/Testably.Abstractions.Testing/Initializer/DirectoryInitializer.cs b/Source/Testably.Abstractions.Testing/Initializer/DirectoryInitializer.cs
index 591bf2e24..e7f012146 100644
--- a/Source/Testably.Abstractions.Testing/Initializer/DirectoryInitializer.cs
+++ b/Source/Testably.Abstractions.Testing/Initializer/DirectoryInitializer.cs
@@ -1,4 +1,5 @@
 using System;
+using Testably.Abstractions.Testing.Helpers;
 
 namespace Testably.Abstractions.Testing.Initializer;
 
@@ -24,7 +25,9 @@ public DirectoryInitializer(FileSystemInitializer<TFileSystem> initializer,
 	public IFileSystemDirectoryInitializer<TFileSystem> Initialized(
 		Action<IFileSystemInitializer<TFileSystem>> subdirectoryInitializer)
 	{
-		FileSystemInitializer<TFileSystem> initializer = new(this, Directory);
+		using IDisposable release = FileSystem.IgnoreStatistics();
+		FileSystemInitializer<TFileSystem> initializer =
+			new(this, FileSystem.Path.Combine(BasePath, Directory.Name));
 		subdirectoryInitializer.Invoke(initializer);
 		return this;
 	}
diff --git a/Source/Testably.Abstractions.Testing/Initializer/FileSystemInitializer.cs b/Source/Testably.Abstractions.Testing/Initializer/FileSystemInitializer.cs
index e88da1161..7c26e11c8 100644
--- a/Source/Testably.Abstractions.Testing/Initializer/FileSystemInitializer.cs
+++ b/Source/Testably.Abstractions.Testing/Initializer/FileSystemInitializer.cs
@@ -10,14 +10,14 @@ internal class FileSystemInitializer<TFileSystem>
 	: IFileSystemInitializer<TFileSystem>
 	where TFileSystem : IFileSystem
 {
-	private readonly string _basePath;
+	protected string BasePath { get; }
 
 	private readonly Dictionary<int, IFileSystemInfo>
 		_initializedFileSystemInfos = new();
 
 	public FileSystemInitializer(TFileSystem fileSystem, string basePath)
 	{
-		_basePath = basePath;
+		BasePath = basePath;
 		FileSystem = fileSystem;
 	}
 
@@ -25,23 +25,23 @@ protected FileSystemInitializer(FileSystemInitializer<TFileSystem> parent)
 	{
 		FileSystem = parent.FileSystem;
 		_initializedFileSystemInfos = parent._initializedFileSystemInfos;
-		_basePath = parent._basePath;
+		BasePath = parent.BasePath;
 	}
 
 	internal FileSystemInitializer(FileSystemInitializer<TFileSystem> parent,
-		IDirectoryInfo subdirectory)
+		string basePath)
 	{
 		FileSystem = parent.FileSystem;
 		using IDisposable release = FileSystem.IgnoreStatistics();
 		_initializedFileSystemInfos = parent._initializedFileSystemInfos;
-		_basePath = FileSystem.Path.Combine(parent._basePath, subdirectory.Name);
+		BasePath = basePath;
 	}
 
 	#region IFileSystemInitializer<TFileSystem> Members
 
 	/// <inheritdoc cref="IFileSystemInitializer{TFileSystem}.BaseDirectory" />
 	public IDirectoryInfo BaseDirectory
-		=> FileSystem.DirectoryInfo.New(_basePath);
+		=> FileSystem.DirectoryInfo.New(BasePath);
 
 	/// <inheritdoc cref="IFileSystemInitializer{TFileSystem}.FileSystem" />
 	public TFileSystem FileSystem { get; }
@@ -78,7 +78,7 @@ public IFileSystemFileInitializer<TFileSystem> WithAFile(string? extension = nul
 			fileName =
 				$"{random.GenerateFileName()}-{random.Next(10000)}.{random.GenerateFileExtension(extension)}";
 		} while (FileSystem.File.Exists(
-			FileSystem.Path.Combine(_basePath, fileName)));
+			FileSystem.Path.Combine(BasePath, fileName)));
 
 		return WithFile(fileName);
 	}
@@ -94,7 +94,7 @@ public IFileSystemDirectoryInitializer<TFileSystem> WithASubdirectory()
 			directoryName =
 				$"{random.GenerateFileName()}-{random.Next(10000)}";
 		} while (FileSystem.Directory.Exists(
-			FileSystem.Path.Combine(_basePath, directoryName)));
+			FileSystem.Path.Combine(BasePath, directoryName)));
 
 		return WithSubdirectory(directoryName);
 	}
@@ -131,7 +131,7 @@ private IDirectoryInfo WithDirectory(DirectoryDescription directory)
 	{
 		using IDisposable release = FileSystem.IgnoreStatistics();
 		IDirectoryInfo directoryInfo = FileSystem.DirectoryInfo.New(
-			FileSystem.Path.Combine(_basePath, directory.Name));
+			FileSystem.Path.Combine(BasePath, directory.Name));
 		if (directoryInfo.Exists)
 		{
 			throw new TestingException(
@@ -146,7 +146,8 @@ private IDirectoryInfo WithDirectory(DirectoryDescription directory)
 
 		FileSystem.Directory.CreateDirectory(directoryInfo.FullName);
 
-		FileSystemInitializer<TFileSystem> subdirectoryInitializer = new(this, directoryInfo);
+		FileSystemInitializer<TFileSystem> subdirectoryInitializer = new(this,
+			FileSystem.Path.Combine(BasePath, directory.Name));
 		foreach (FileSystemInfoDescription children in directory.Children)
 		{
 			subdirectoryInitializer.WithFileOrDirectory(children);
@@ -164,7 +165,7 @@ private IFileInfo WithFile(FileDescription file)
 	{
 		using IDisposable release = FileSystem.IgnoreStatistics();
 		IFileInfo fileInfo = FileSystem.FileInfo.New(
-			FileSystem.Path.Combine(_basePath, file.Name));
+			FileSystem.Path.Combine(BasePath, file.Name));
 		if (fileInfo.Exists)
 		{
 			throw new TestingException(
diff --git a/Tests/Testably.Abstractions.Testing.Tests/FileSystemInitializer/FileSystemInitializerTests.cs b/Tests/Testably.Abstractions.Testing.Tests/FileSystemInitializer/FileSystemInitializerTests.cs
index 295c56cef..119d9be5f 100644
--- a/Tests/Testably.Abstractions.Testing.Tests/FileSystemInitializer/FileSystemInitializerTests.cs
+++ b/Tests/Testably.Abstractions.Testing.Tests/FileSystemInitializer/FileSystemInitializerTests.cs
@@ -125,6 +125,44 @@ public async Task With_FilesAndDirectories_ShouldBothBeCreated(string fileName,
 		await That(fileSystem.File.Exists(fileName)).IsTrue();
 		await That(fileSystem.Directory.Exists(directoryName)).IsTrue();
 	}
+	
+	[Theory]
+	[AutoData]
+	public async Task With_FilesAndDirectoriesWithMultiplePathComponents_ShouldBeCreatedAtTheCorrectPath(
+		string level1, string level2, string fileName)
+	{
+		string directoryPath = Path.Combine(level1, level2);
+		string filePath = Path.Combine(directoryPath, fileName);
+		FileDescription fileDescription = new(fileName);
+		DirectoryDescription directoryDescription = new(directoryPath, fileDescription);
+		MockFileSystem fileSystem = new();
+		IFileSystemInitializer<MockFileSystem> sut = fileSystem.Initialize();
+
+		sut.With(directoryDescription);
+		
+		await That(fileSystem.Statistics.TotalCount).IsEqualTo(0);
+		await That(fileSystem.Directory.Exists(directoryPath)).IsTrue();
+		await That(fileSystem.File.Exists(filePath)).IsTrue();
+	}
+
+	[Theory]
+	[AutoData]
+	public async Task With_AbsoluteDirectoryWithChildren_ShouldBeCreatedAtTheCorrectPath(
+		string level1, string level2, string fileName)
+	{
+		string directoryPath = Path.GetFullPath(Path.Combine(level1, level2));
+		string filePath = Path.Combine(directoryPath, fileName);
+		FileDescription fileDescription = new(fileName);
+		DirectoryDescription directoryDescription = new(directoryPath, fileDescription);
+		MockFileSystem fileSystem = new();
+		IFileSystemInitializer<MockFileSystem> sut = fileSystem.Initialize();
+
+		sut.With(directoryDescription);
+		
+		await That(fileSystem.Statistics.TotalCount).IsEqualTo(0);
+		await That(fileSystem.Directory.Exists(directoryPath)).IsTrue();
+		await That(fileSystem.File.Exists(filePath)).IsTrue();
+	}
 
 	[Theory]
 	[AutoData]
@@ -186,6 +224,24 @@ public async Task WithFile_MissingDirectory_ShouldCreateDirectory(string directo
 		await That(fileSystem.Directory.Exists(directoryPath)).IsTrue();
 	}
 
+	[Theory]
+	[AutoData]
+	public async Task WithFile_MultiplePathComponents_ShouldCreateDirectories(string level1,
+		string level2, string level3, string fileName)
+	{
+		string path = Path.Combine(level1, level2, level3, fileName);
+		MockFileSystem fileSystem = new();
+		IFileSystemInitializer<MockFileSystem> sut = fileSystem.Initialize();
+
+		sut.WithFile(path);
+
+		await That(fileSystem.Statistics.TotalCount).IsEqualTo(0);
+		await That(fileSystem.File.Exists(path)).IsTrue();
+		await That(fileSystem.Directory.Exists(level1)).IsTrue();
+		await That(fileSystem.Directory.Exists(Path.Combine(level1, level2))).IsTrue();
+		await That(fileSystem.Directory.Exists(Path.Combine(level1, level2, level3))).IsTrue();
+	}
+
 	[Theory]
 	[AutoData]
 	public async Task WithSubdirectories_ShouldCreateAllDirectories(string[] paths)