diff --git a/tests/Sharpify.CommandLineInterface.Tests/ArgumentsIsolatedTests.cs b/tests/Sharpify.CommandLineInterface.Tests/ArgumentsIsolatedTests.cs
index 6e8f19e..455f9d2 100644
--- a/tests/Sharpify.CommandLineInterface.Tests/ArgumentsIsolatedTests.cs
+++ b/tests/Sharpify.CommandLineInterface.Tests/ArgumentsIsolatedTests.cs
@@ -9,16 +9,16 @@ public class ArgumentsIsolatedTests {
     [Fact]
 	public void Arguments_Positional_BeforeForwarding() {
 		// Positional 0 [Command]
-		Args.TryGetValue(0, out var pos0).Should().BeTrue();
-		pos0.Should().Be("command");
+		Assert.True(Args.TryGetValue(0, out var pos0));
+		Assert.Equal("command", pos0);
 
 		// Positional 0 [positional]
-		Args.TryGetValue(1, out var pos1).Should().BeTrue();
-		pos1.Should().Be("positional");
+		Assert.True(Args.TryGetValue(1, out var pos1));
+		Assert.Equal("positional", pos1);
 
 		// Positional 0 [positional2]
-		Args.TryGetValue(2, out var pos2).Should().BeTrue();
-		pos2.Should().Be("positional2");
+		Assert.True(Args.TryGetValue(2, out var pos2));
+		Assert.Equal("positional2", pos2);
 	}
 
 	[Fact]
@@ -29,12 +29,12 @@ public void Arguments_Positional_AfterForwarding() {
 		// positional should be at 0, and positional2 at 1.
 
 		// Positional 0 [positional]
-		forwarded.TryGetValue(0, out var pos0).Should().BeTrue();
-		pos0.Should().Be("positional");
+		Assert.True(forwarded.TryGetValue(0, out var pos0));
+		Assert.Equal("positional", pos0);
 
 		// Positional 1 [positional2]
-		forwarded.TryGetValue(1, out var pos1).Should().BeTrue();
-		pos1.Should().Be("positional2");
+		Assert.True(forwarded.TryGetValue(1, out var pos1));
+		Assert.Equal("positional2", pos1);
 	}
 
 	[Fact]
@@ -42,11 +42,11 @@ public void Arguments_Named_BeforeForwarding() {
 		// named1 - Harold
 		// named2 - Finch
 
-		Args.TryGetValue("named1", out var firstName).Should().BeTrue();
-		firstName.Should().Be("Harold");
+		Assert.True(Args.TryGetValue("named1", out var firstName));
+		Assert.Equal("Harold", firstName);
 
-		Args.TryGetValue("named2", out var lastName).Should().BeTrue();
-		lastName.Should().Be("Finch");
+		Assert.True(Args.TryGetValue("named2", out var lastName));
+		Assert.Equal("Finch", lastName);
 	}
 
 	[Fact]
@@ -56,214 +56,214 @@ public void Arguments_Named_AfterForwarding() {
 		// named1 - Harold
 		// named2 - Finch
 
-		forwarded.TryGetValue("named1", out var firstName).Should().BeTrue();
-		firstName.Should().Be("Harold");
+		Assert.True(forwarded.TryGetValue("named1", out var firstName));
+		Assert.Equal("Harold", firstName);
 
-		forwarded.TryGetValue("named2", out var lastName).Should().BeTrue();
-		lastName.Should().Be("Finch");
+		Assert.True(forwarded.TryGetValue("named2", out var lastName));
+		Assert.Equal("Finch", lastName);
 	}
 
 	[Fact]
 	public void Arguments_Flag_BeforeForwarding() {
-		Args.HasFlag("flag").Should().BeTrue();
+		Assert.True(Args.HasFlag("flag"));
 	}
 
 	[Fact]
 	public void Arguments_Flag_AfterForwarding() {
 		var forwarded = Args.ForwardPositionalArguments();
-		forwarded.HasFlag("flag").Should().BeTrue();
+		Assert.True(forwarded.HasFlag("flag"));
 	}
 
 	[Fact]
 	public void Arguments_Contains_Key() {
-		Args.Contains("named1").Should().BeTrue();
+		Assert.True(Args.Contains("named1"));
 	}
 
 	[Fact]
 	public void Arguments_Contains_Position() {
-		Args.Contains(0).Should().BeTrue();
+		Assert.True(Args.Contains(0));
 	}
 
 	[Fact]
 	public void Arguments_Named_Array_String() {
-		Args.TryGetValues("words", "|", out var words).Should().BeTrue();
-		words.Should().BeEquivalentTo(["word1", "word2"]);
+		Assert.True(Args.TryGetValues("words", "|", out var words));
+		Assert.Equal(["word1", "word2"], words); 
 	}
 
 	[Fact]
 	public void Arguments_Named_MultipleKeys_Array_String() {
 		var args = Parser.ParseArguments("command --words word1|word2")!;
-		args.TryGetValues(["words", "w"], "|", out var words).Should().BeTrue();
-		words.Should().BeEquivalentTo(["word1", "word2"]);
+		Assert.True(args.TryGetValues(["words", "w"], "|", out var words));
+		Assert.Equal(["word1", "word2"], words);
 		args = Parser.ParseArguments("command --w word1|word2")!;
-		args.TryGetValues(["words", "w"], "|", out var w).Should().BeTrue();
-		w.Should().BeEquivalentTo(["word1", "word2"]);
+		Assert.True(args.TryGetValues(["words", "w"], "|", out var w));
+		Assert.Equal(["word1", "word2"], w);
 	}
 
 	[Fact]
 	public void Arguments_Named_MultipleKeys_Array_Int() {
 		var args = Parser.ParseArguments("command --numbers 1|2")!;
-		args.TryGetValues<int>(["numbers", "n"], "|", out var numbers).Should().BeTrue();
-		numbers.Should().BeEquivalentTo([1, 2]);
+		Assert.True(args.TryGetValues<int>(["numbers", "n"], "|", out var numbers));
+		Assert.Equal([1, 2], numbers);
 		args = Parser.ParseArguments("command -n 1|2")!;
-		args.TryGetValues<int>(["numbers", "n"], "|", out var n).Should().BeTrue();
-		n.Should().BeEquivalentTo([1, 2]);
+		Assert.True(args.TryGetValues<int>(["numbers", "n"], "|", out var n));
+		Assert.Equal([1, 2], n);
 	}
 
 	[Fact]
 	public void Arguments_Positional_Array_String() {
 		var args = Parser.ParseArguments("command q1|q2")!;
-		args.TryGetValues(1, "|", out var words).Should().BeTrue();
-		words.Should().BeEquivalentTo(["q1", "q2"]);
+		Assert.True(args.TryGetValues(1, "|", out var words));
+		Assert.Equal(["q1", "q2"], words);
 	}
 
 	[Fact]
 	public void Arguments_Named_Array_Int() {
-		Args.TryGetValues<int>("numbers", "|", out var numbers).Should().BeTrue();
-		numbers.Should().BeEquivalentTo([1, 2]);
+		Assert.True(Args.TryGetValues<int>("numbers", "|", out var numbers));
+		Assert.Equal([1, 2], numbers);
 	}
 
 	[Fact]
 	public void Arguments_Positional_Array_Int() {
 		var args = Parser.ParseArguments("command 1|2")!;
-		args.TryGetValues<int>(1, "|", out var numbers).Should().BeTrue();
-		numbers.Should().BeEquivalentTo([1, 2]);
+		Assert.True(args.TryGetValues<int>(1, "|", out var numbers));
+		Assert.Equal([1, 2], numbers);
 	}
 
 	[Fact]
 	public void Arguments_TryGetValue_Named_Int() {
 		var args = Parser.ParseArguments("command -x 5 -y Hello")!;
-		args.TryGetValue("x", 0, out int x).Should().BeTrue();
-		x.Should().Be(5);
-		args.TryGetValue("y", 0, out int y).Should().BeFalse();
-		y.Should().Be(0);
+		Assert.True(args.TryGetValue("x", 0, out int x));
+		Assert.Equal(5, x);
+		Assert.False(args.TryGetValue("y", 0, out int y));
+		Assert.Equal(0, y);
 	}
 
 	[Fact]
 	public void Arguments_TryGetValue_Named_Double() {
 		var args = Parser.ParseArguments("command -x 5 -y Hello")!;
-		args.TryGetValue("x", 0, out double x).Should().BeTrue();
-		x.Should().Be(5);
-		args.TryGetValue("y", 0, out double y).Should().BeFalse();
-		y.Should().Be(0);
+		Assert.True(args.TryGetValue("x", 0, out double x));
+		Assert.Equal(5, x);
+		Assert.False(args.TryGetValue("y", 0, out double y));
+		Assert.Equal(0, y);
 	}
 
 	[Fact]
 	public void Arguments_GetValue_Named_Int() {
 		var args = Parser.ParseArguments("command -x 5 -y Hello")!;
-		args.GetValue("x", 0).Should().Be(5);
-		args.GetValue("y", 0).Should().Be(0);
+		Assert.Equal(5, args.GetValue("x", 0));
+		Assert.Equal(0, args.GetValue("y", 0));
 	}
 
 	[Fact]
 	public void Arguments_GetValue_Named_MultipleKeys_Int() {
 		var args = Parser.ParseArguments("command -x 5 -y Hello")!;
-		args.GetValue(["x", "one"], 0).Should().Be(5);
+		Assert.Equal(5, args.GetValue(["x", "one"], 0));
 		args = Parser.ParseArguments("command --one 5 -y Hello")!;
-		args.GetValue(["x", "one"], 0).Should().Be(5);
+		Assert.Equal(5, args.GetValue(["x", "one"], 0));
 	}
 
 	[Fact]
 	public void Arguments_TryGetValue_Positional_Int() {
 		var args = Parser.ParseArguments("command 5 Hello")!;
-		args.TryGetValue(1, 0, out double x).Should().BeTrue();
-		x.Should().Be(5);
-		args.TryGetValue(2, 0, out double y).Should().BeFalse();
-		y.Should().Be(0);
+		Assert.True(args.TryGetValue(1, 0, out double x));
+		Assert.Equal(5, x);
+		Assert.False(args.TryGetValue(2, 0, out double y));
+		Assert.Equal(0, y);
 	}
 
 	[Fact]
 	public void Arguments_GetValue_Positional_Int() {
 		var args = Parser.ParseArguments("command 5 Hello")!;
-		args.GetValue(1, 0).Should().Be(5);
-		args.GetValue(2, 0).Should().Be(0);
+		Assert.Equal(5, args.GetValue(1, 0));
+		Assert.Equal(0, args.GetValue(2, 0));
 	}
 
 	[Fact]
 	public void Arguments_TryGetEnum_Positional() {
 		var args = Parser.ParseArguments("command Blue")!;
-		args.TryGetEnum(1, out ConsoleColor color).Should().BeTrue();
-		color.Should().Be(ConsoleColor.Blue);
+		Assert.True(args.TryGetEnum(1, out ConsoleColor color));
+		Assert.Equal(ConsoleColor.Blue, color);
 	}
 
 	[Fact]
 	public void Arguments_TryGetEnum_Positional_IgnoreCase() {
 		var args = Parser.ParseArguments("command bLue")!;
-		args.TryGetEnum(1, true, out ConsoleColor color).Should().BeTrue();
-		color.Should().Be(ConsoleColor.Blue);
+		Assert.True(args.TryGetEnum(1, true, out ConsoleColor color));
+		Assert.Equal(ConsoleColor.Blue, color);
 	}
 
 	[Fact]
 	public void Arguments_TryGetEnum_Named() {
 		var args = Parser.ParseArguments("command --color Blue")!;
-		args.TryGetEnum("color", out ConsoleColor color).Should().BeTrue();
-		color.Should().Be(ConsoleColor.Blue);
+		Assert.True(args.TryGetEnum("color", out ConsoleColor color));
+		Assert.Equal(ConsoleColor.Blue, color);
 	}
 
 	[Fact]
 	public void Arguments_TryGetEnum_Named_IgnoreCase() {
 		var args = Parser.ParseArguments("command --color bLue")!;
-		args.TryGetEnum("color", true, out ConsoleColor color).Should().BeTrue();
-		color.Should().Be(ConsoleColor.Blue);
+		Assert.True(args.TryGetEnum("color", true, out ConsoleColor color));
+		Assert.Equal(ConsoleColor.Blue, color);
 	}
 
 	[Fact]
 	public void Arguments_TryGetEnum_Named_MultipleKeys() {
 		var args = Parser.ParseArguments("command --color Blue")!;
-		args.TryGetEnum(["color", "c"], out ConsoleColor color).Should().BeTrue();
-		color.Should().Be(ConsoleColor.Blue);
+		Assert.True(args.TryGetEnum(["color", "c"], out ConsoleColor color));
+		Assert.Equal(ConsoleColor.Blue, color);
 		args = Parser.ParseArguments("command -c Blue")!;
-		args.TryGetEnum(["color", "c"], out ConsoleColor c).Should().BeTrue();
-		c.Should().Be(ConsoleColor.Blue);
+		Assert.True(args.TryGetEnum(["color", "c"], out ConsoleColor c));
+		Assert.Equal(ConsoleColor.Blue, c);
 	}
 
 	[Fact]
 	public void Arguments_TryGetEnum_Named_MultipleKeys_IgnoreCase() {
 		var args = Parser.ParseArguments("command --color bLue")!;
-		args.TryGetEnum(["color", "c"], true, out ConsoleColor color).Should().BeTrue();
-		color.Should().Be(ConsoleColor.Blue);
+		Assert.True(args.TryGetEnum(["color", "c"], true, out ConsoleColor color));
+		Assert.Equal(ConsoleColor.Blue, color);
 		args = Parser.ParseArguments("command -c bLue")!;
-		args.TryGetEnum(["color", "c"], true, out ConsoleColor c).Should().BeTrue();
-		c.Should().Be(ConsoleColor.Blue);
+		Assert.True(args.TryGetEnum(["color", "c"], true, out ConsoleColor c));
+		Assert.Equal(ConsoleColor.Blue, c);
 	}
 
 	[Fact]
 	public void Arguments_GetEnum_Positional() {
 		var args = Parser.ParseArguments("command Blue")!;
-		args.GetEnum(1, ConsoleColor.Black).Should().Be(ConsoleColor.Blue);
+		Assert.Equal(ConsoleColor.Blue, args.GetEnum(1, ConsoleColor.Black));
 	}
 
 	[Fact]
 	public void Arguments_GetEnum_Positional_IgnoreCase() {
 		var args = Parser.ParseArguments("command bLue")!;
-		args.GetEnum(1, ConsoleColor.Black, true).Should().Be(ConsoleColor.Blue);
+		Assert.Equal(ConsoleColor.Blue, args.GetEnum(1, ConsoleColor.Black, true));
 	}
 
 	[Fact]
 	public void Arguments_GetEnum_Named() {
 		var args = Parser.ParseArguments("command --color Blue")!;
-		args.GetEnum("color", ConsoleColor.Black).Should().Be(ConsoleColor.Blue);
+		Assert.Equal(ConsoleColor.Blue, args.GetEnum("color", ConsoleColor.Black));
 	}
 
 	[Fact]
 	public void Arguments_GetEnum_Named_IgnoreCase() {
 		var args = Parser.ParseArguments("command --color bLue")!;
-		args.GetEnum("color", ConsoleColor.Black, true).Should().Be(ConsoleColor.Blue);
+		Assert.Equal(ConsoleColor.Blue, args.GetEnum("color", ConsoleColor.Black, true));
 	}
 
 	[Fact]
 	public void Arguments_GetEnum_Named_MultipleKeys() {
 		var args = Parser.ParseArguments("command --color Blue")!;
-		args.GetEnum(["color", "c"], ConsoleColor.Black).Should().Be(ConsoleColor.Blue);
+		Assert.Equal(ConsoleColor.Blue, args.GetEnum(["color", "c"], ConsoleColor.Black));
 		args = Parser.ParseArguments("command -c Blue")!;
-		args.GetEnum(["color", "c"], ConsoleColor.Black).Should().Be(ConsoleColor.Blue);
+		Assert.Equal(ConsoleColor.Blue, args.GetEnum(["color", "c"], ConsoleColor.Black));
 	}
 
 	[Fact]
 	public void Arguments_GetEnum_Named_MultipleKeys_IgnoreCase() {
 		var args = Parser.ParseArguments("command --color bLue")!;
-		args.GetEnum(["color", "c"], ConsoleColor.Black, true).Should().Be(ConsoleColor.Blue);
+		Assert.Equal(ConsoleColor.Blue, args.GetEnum(["color", "c"], ConsoleColor.Black, true));
 		args = Parser.ParseArguments("command -c bLue")!;
-		args.GetEnum(["color", "c"], ConsoleColor.Black, true).Should().Be(ConsoleColor.Blue);
+		Assert.Equal(ConsoleColor.Blue, args.GetEnum(["color", "c"], ConsoleColor.Black, true));
 	}
 }
\ No newline at end of file
diff --git a/tests/Sharpify.CommandLineInterface.Tests/CliBuilderTests.cs b/tests/Sharpify.CommandLineInterface.Tests/CliBuilderTests.cs
index e597074..5542b3b 100644
--- a/tests/Sharpify.CommandLineInterface.Tests/CliBuilderTests.cs
+++ b/tests/Sharpify.CommandLineInterface.Tests/CliBuilderTests.cs
@@ -9,14 +9,14 @@ public class CliBuilderTests {
 	public void Build_WhenEmpty_ReturnsEmpty() {
 		var action = () => CliRunner.CreateBuilder().Build();
 
-		action.Should().Throw<InvalidOperationException>();
+		Assert.Throws<InvalidOperationException>(action);
 	}
 
 	[Fact]
 	public void Build_WhenNotEmpty_ReturnsCliRunner() {
 		var action = () => CliRunner.CreateBuilder().AddCommand(new EchoCommand()).Build();
 
-		action.Should().NotThrow<InvalidOperationException>();
+		action();
 	}
 
 	[Fact]
@@ -25,7 +25,7 @@ public void Build_WhenNotEmpty_ReturnsCliRunnerWithCommands() {
 
 		var cliRunner = CliRunner.CreateBuilder().AddCommand(echo).Build();
 
-		cliRunner.Commands.Should().Contain(echo);
+		Assert.Contains(echo, cliRunner.Commands);
 	}
 
 	[Fact]
@@ -39,7 +39,7 @@ public async Task Runner_WithCustomWriter_OutputsCommandHelpToWriter() {
                            .Build();
 		await cliRunner.RunAsync("echo --help");
 
-		writer.ToString().Should().Contain("echo <message>");
+		Assert.Contains("echo <message>", writer.ToString());
 	}
 
 	[Fact]
@@ -61,12 +61,12 @@ public async Task Runner_WithCustomWriter_SingleCommand_HelpCommand_OutputsAllIn
 		await cliRunner.RunAsync("help", false);
 
 		var output = writer.ToString();
-		output.Should().Contain("Single");
-		output.Should().Contain("A single command");
-		output.Should().Contain("Version: 1.0.0");
-		output.Should().Contain("Author: David");
-		output.Should().Contain("License: MIT");
-		output.Should().Contain(single.Usage);
+		Assert.Contains("Single", output);
+		Assert.Contains("A single command", output);
+		Assert.Contains("Version: 1.0.0", output);
+		Assert.Contains("Author: David", output);
+		Assert.Contains("License: MIT", output);
+		Assert.Contains(single.Usage, output);
 	}
 
 	[Theory]
@@ -82,7 +82,7 @@ public async Task Runner_WithCustomWriter_SingleCommand_HelpCommand_OutputsComma
                            .Build();
 		await cliRunner.RunAsync(input, false);
 
-		writer.ToString().Should().Contain(single.Usage);
+		Assert.Contains(single.Usage, writer.ToString());
 	}
 
 	[Theory]
@@ -99,7 +99,7 @@ public async Task Runner_WithCustomWriter_SingleCommand_VersionCommand_OutputsVe
                            .Build();
 		await cliRunner.RunAsync(input, false);
 
-		writer.ToString().Should().Contain("Version: 1.0.0");
+		Assert.Contains("Version: 1.0.0", writer.ToString());
 	}
 
 	[Fact]
@@ -115,8 +115,8 @@ public async Task Runner_WithCustomWriterMultipleCommands_OutputsGeneralHelpToWr
                            .Build();
 		await cliRunner.RunAsync("--help");
 
-		writer.ToString().Should().Contain("Echo");
-		writer.ToString().Should().Contain("Add");
+		Assert.Contains("Echo", writer.ToString());
+		Assert.Contains("Add", writer.ToString());
 	}
 
 	[Fact]
@@ -130,7 +130,7 @@ public async Task Runner_WithCustomWriterAddCommand_ReadOnlySpanInput() {
                            .Build();
 		await cliRunner.RunAsync(["add", "1", "2"]);
 
-		writer.ToString().Should().Contain("3");
+		Assert.Contains("3", writer.ToString());
 	}
 
 	[Fact]
@@ -147,7 +147,7 @@ public async Task Runner_WithCustomWriterAndMetadata_HelpCommand_OutputsGeneralH
                            .Build();
 		await cliRunner.RunAsync("help");
 
-		writer.ToString().Should().Contain("Dave");
+		Assert.Contains("Dave", writer.ToString());
 	}
 
 	[Fact]
@@ -164,7 +164,7 @@ public async Task Runner_WithCustomWriterAndMetadata_HelpFlag_OutputsGeneralHelp
                            .Build();
 		await cliRunner.RunAsync("--help");
 
-		writer.ToString().Should().Contain("Dave");
+		Assert.Contains("Dave", writer.ToString());
 	}
 
 	[Fact]
@@ -184,7 +184,7 @@ public async Task Runner_WithCustomWriterAndMetadata_VersionCommand_OutputsVersi
                            .Build();
 		await cliRunner.RunAsync("version");
 
-		writer.ToString().Should().Contain("Version: 1.0.0");
+		Assert.Contains("Version: 1.0.0", writer.ToString());
 	}
 
 	[Fact]
@@ -204,7 +204,7 @@ public async Task Runner_WithCustomWriterAndMetadata_VersionFlag_OutputsVersionT
                            .Build();
 		await cliRunner.RunAsync("--version");
 
-		writer.ToString().Should().Contain("Version: 1.0.0");
+		Assert.Contains("Version: 1.0.0", writer.ToString());
 	}
 
 	[Fact]
@@ -222,7 +222,7 @@ public async Task Runner_WithCustomWriterAndCustomHeader_OutputsGeneralHelpToWri
                            .Build();
 		await cliRunner.RunAsync("--help");
 
-		writer.ToString().Should().Contain("Dave");
+		Assert.Contains("Dave", writer.ToString());
 	}
 
 	[Fact]
@@ -240,9 +240,9 @@ public void Runner_WithOrderedCommands_IsOrdered() {
 						   .SetOutputWriter(writer)
 						   .Build();
 		var copy = cliRunner.Commands;
-		copy[0].Should().Be(add);
-		copy[1].Should().Be(echo);
-		copy[2].Should().Be(sAdd);
+		Assert.Equal(add, copy[0]);
+		Assert.Equal(echo, copy[1]);
+		Assert.Equal(sAdd, copy[2]);
 	}
 
 	[Fact]
@@ -255,8 +255,8 @@ public async Task Runner_WithSingleCommand_NoParams() {
 						   .Build();
 		var exitCode = await cliRunner.RunAsync("", false);
 
-		exitCode.Should().Be(0);
-		value.Value.Should().BeTrue();
+		Assert.Equal(0, exitCode);
+		Assert.True(value.Value);
 	}
 
 	[Fact]
@@ -268,6 +268,6 @@ public async Task Runner_WithMultipleCommands_CaseSensitive() {
 						   .Build();
 		var exitCode = await cliRunner.RunAsync("aDD 1 2");
 
-		exitCode.Should().NotBe(0);
+		Assert.NotEqual(0, exitCode);
 	}
 }
\ No newline at end of file
diff --git a/tests/Sharpify.CommandLineInterface.Tests/GlobalUsings.cs b/tests/Sharpify.CommandLineInterface.Tests/GlobalUsings.cs
index 0895015..f55b219 100644
--- a/tests/Sharpify.CommandLineInterface.Tests/GlobalUsings.cs
+++ b/tests/Sharpify.CommandLineInterface.Tests/GlobalUsings.cs
@@ -1,3 +1,2 @@
 global using Xunit;
-global using Sharpify.CommandLineInterface;
-global using FluentAssertions;
\ No newline at end of file
+global using Sharpify.CommandLineInterface;
\ No newline at end of file
diff --git a/tests/Sharpify.CommandLineInterface.Tests/ParserArgumentsTests.cs b/tests/Sharpify.CommandLineInterface.Tests/ParserArgumentsTests.cs
index 77cdccf..cb3e39f 100644
--- a/tests/Sharpify.CommandLineInterface.Tests/ParserArgumentsTests.cs
+++ b/tests/Sharpify.CommandLineInterface.Tests/ParserArgumentsTests.cs
@@ -5,7 +5,7 @@ namespace Sharpify.CommandLineInterface.Tests;
 public class ParserArgumentsTests {
 	[Fact]
 	public void Split_WhenEmpty_ReturnsEmptyList() {
-		Parser.Split("").IsDisabled.Should().BeTrue();
+		Assert.True(Parser.Split("").IsDisabled);
 	}
 
 	[Theory]
@@ -14,7 +14,7 @@ public void Split_WhenEmpty_ReturnsEmptyList() {
 	[InlineData("\"hello world\"", new[] { "hello world" })]
 	[InlineData("\"hello world\" \"hello world\"", new[] { "hello world", "hello world" })]
 	public void Split_WhenValid_ReturnsValid(string input, string[] expected) {
-		Parser.Split(input).WrittenSpan.SequenceEqual(expected).Should().BeTrue();
+		Assert.Equal(expected, Parser.Split(input).WrittenSpan);
 	}
 
 	[Fact]
@@ -40,103 +40,103 @@ public void MapArguments_Valid() {
 		for (var i = 0; i < args.Length; i++) {
 			var localArgs = args[i];
 			var localArguments = Parser.MapArguments(localArgs, StringComparer.CurrentCultureIgnoreCase);
-			localArguments.Should().BeEquivalentTo(expected[i]);
+			Assert.Equal(expected[i], localArguments);
 		}
 	}
 
 	[Fact]
 	public void Parse_WhenEmpty_ReturnsNull() {
-		Parser.ParseArguments("").Should().BeNull();
+		Assert.Null(Parser.ParseArguments(""));
 	}
 
 	[Fact]
 	public void Parse_And_Arguments_Command_Name() {
 		const string input = "command --message \"hello world\" --code 404 --force";
 		var arguments = Parser.ParseArguments(input);
-		arguments.Should().NotBeNull();
-		arguments!.TryGetValue(0, out var command).Should().BeTrue();
-		command.Should().Be("command");
+		Assert.NotNull(arguments);
+		Assert.True(arguments!.TryGetValue(0, out var command));
+		Assert.Equal("command", command);
 	}
 
 	[Fact]
 	public void Parse_And_Arguments_Named_Argument() {
 		const string input = "command --message \"hello world\" --code 404 --force";
 		var arguments = Parser.ParseArguments(input);
-		arguments.Should().NotBeNull();
-		arguments!.TryGetValue("message", out var message).Should().BeTrue();
-		message.Should().Be("hello world");
+		Assert.NotNull(arguments);
+		Assert.True(arguments!.TryGetValue("message", out var message));
+		Assert.Equal("hello world", message);
 	}
 
 	[Fact]
 	public void Parse_And_Arguments_Named_Argument_Multiple() {
 		const string input = "command --message \"hello world\" --code 404 --force";
 		var arguments = Parser.ParseArguments(input);
-		arguments.Should().NotBeNull();
-		arguments!.TryGetValues("message", " ", out var message).Should().BeTrue();
-		message.Should().BeEquivalentTo(["hello", "world"]);
+		Assert.NotNull(arguments);
+		Assert.True(arguments!.TryGetValues("message", " ", out var message));
+		Assert.Equal(["hello", "world"], message);
 	}
 
 	[Fact]
 	public void Parse_And_Arguments_Named_Argument_With_Aliases() {
 		const string input = "command --message \"hello world\" --code 404 --force";
 		var arguments = Parser.ParseArguments(input);
-		arguments.Should().NotBeNull();
-		arguments!.TryGetValue(["message", "m"], out var message).Should().BeTrue();
-		message.Should().Be("hello world");
+		Assert.NotNull(arguments);
+		Assert.True(arguments!.TryGetValue(["message", "m"], out var message));
+		Assert.Equal("hello world", message);
 	}
 
 	[Fact]
 	public void Parse_And_Arguments_Named_Argument_With_Aliases_Inverted() {
 		const string input = "command -m \"hello world\" --code 404 --force";
 		var arguments = Parser.ParseArguments(input);
-		arguments.Should().NotBeNull();
-		arguments!.TryGetValue(["message", "m"], out var message).Should().BeTrue();
-		message.Should().Be("hello world");
+		Assert.NotNull(arguments);
+		Assert.True(arguments!.TryGetValue(["message", "m"], out var message));
+		Assert.Equal("hello world", message);
 	}
 
 	[Fact]
 	public void Parse_And_Arguments_Named_Argument_Integer_WithDefault() {
 		const string input = "command --message \"hello world\" --code 404 --force";
 		var arguments = Parser.ParseArguments(input);
-		arguments.Should().NotBeNull();
-		arguments!.TryGetValue("code", 12, out var code).Should().BeTrue();
-		code.Should().Be(404);
+		Assert.NotNull(arguments);
+		Assert.True(arguments!.TryGetValue("code", 12, out var code));
+		Assert.Equal(404, code);
 	}
 
 	[Fact]
 	public void Parse_And_Arguments_With_Flag() {
 		const string input = "command --message \"hello world\" --code 404 --force";
 		var arguments = Parser.ParseArguments(input);
-		arguments.Should().NotBeNull();
-		arguments!.HasFlag("force").Should().BeTrue();
+		Assert.NotNull(arguments);
+		Assert.True(arguments!.HasFlag("force"));
 	}
 
 	[Fact]
 	public void Parse_And_Arguments_Positional_Negative_Numeric() {
 		const string input = "command -5 -9";
 		var arguments = Parser.ParseArguments(input);
-		arguments.Should().NotBeNull();
-		arguments!.TryGetValue(1, 0, out int num).Should().BeTrue();
-		num.Should().Be(-5);
-		arguments!.TryGetValue(2, 0, out int num2).Should().BeTrue();
-		num2.Should().Be(-9);
+		Assert.NotNull(arguments);
+		Assert.True(arguments!.TryGetValue(1, 0, out int num));
+		Assert.Equal(-5, num);
+		Assert.True(arguments!.TryGetValue(2, 0, out int num2));
+		Assert.Equal(-9, num2);
 	}
 
 	[Fact]
 	public void Arguments_ForwardPositional_Works() {
 		const string input = "command delete --code 404 --force";
 		var arguments = Parser.ParseArguments(input);
-		arguments.Should().NotBeNull();
+		Assert.NotNull(arguments);
 		var containsCommandAtPosition0 = arguments!.TryGetValue(0, out var command);
-		containsCommandAtPosition0.Should().BeTrue();
-		command.Should().Be("command");
+		Assert.True(containsCommandAtPosition0);
+		Assert.Equal("command", command);
 		var containsDelete = arguments.TryGetValue(1, out var delete);
-		containsDelete.Should().BeTrue();
-		delete.Should().Be("delete");
+		Assert.True(containsDelete);
+		Assert.Equal("delete", delete);
 		var forwarded = arguments.ForwardPositionalArguments();
-		forwarded.Should().NotBeNull();
+		Assert.NotNull(forwarded);
 		var first = forwarded!.TryGetValue(0, out var firstArg);
-		first.Should().BeTrue();
-		firstArg.Should().Be("delete");
+		Assert.True(first);
+		Assert.Equal("delete", firstArg);
 	}
 }
\ No newline at end of file
diff --git a/tests/Sharpify.CommandLineInterface.Tests/Sharpify.CommandLineInterface.Tests.csproj b/tests/Sharpify.CommandLineInterface.Tests/Sharpify.CommandLineInterface.Tests.csproj
index 5931e82..0bebe05 100644
--- a/tests/Sharpify.CommandLineInterface.Tests/Sharpify.CommandLineInterface.Tests.csproj
+++ b/tests/Sharpify.CommandLineInterface.Tests/Sharpify.CommandLineInterface.Tests.csproj
@@ -10,19 +10,18 @@
 
     <ItemGroup>
         <PackageReference Include="ConsoleDump" Version="0.7.0" />
-        <PackageReference Include="FluentAssertions" Version="6.12.2" />
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
         <PackageReference Include="PrivateProxy" Version="1.0.2">
           <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
           <PrivateAssets>all</PrivateAssets>
         </PackageReference>
         <PackageReference Include="Sharpify" Version="2.5.0" />
-        <PackageReference Include="xunit" Version="2.9.2" />
-        <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+        <PackageReference Include="xunit" Version="2.9.3" />
+        <PackageReference Include="xunit.runner.visualstudio" Version="3.0.1">
           <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
           <PrivateAssets>all</PrivateAssets>
         </PackageReference>
-        <PackageReference Include="coverlet.collector" Version="6.0.2">
+        <PackageReference Include="coverlet.collector" Version="6.0.3">
           <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
           <PrivateAssets>all</PrivateAssets>
         </PackageReference>
diff --git a/tests/Sharpify.Data.Tests/DatabaseEncryptedIgnoreCaseTests.cs b/tests/Sharpify.Data.Tests/DatabaseEncryptedIgnoreCaseTests.cs
index cfc4204..5216fe3 100644
--- a/tests/Sharpify.Data.Tests/DatabaseEncryptedIgnoreCaseTests.cs
+++ b/tests/Sharpify.Data.Tests/DatabaseEncryptedIgnoreCaseTests.cs
@@ -46,8 +46,8 @@ public void SerializeAndDeserialize() {
             IgnoreCase = true,
         });
 
-        database2.TryGetValue("TEST", out Person result).Should().BeTrue();
-        result.Should().Be(new Person("David", 27));
+        Assert.True(database2.TryGetValue("TEST", out Person result));
+        Assert.Equal(new Person("David", 27), result);
     }
 
     [Fact]
@@ -64,8 +64,8 @@ public async Task AsyncSerializeDeserialize() {
         using var db2 = await AsyncFactory(db.Path);
 
         // Assert
-        db2.Database.TryGetValue("TEST", out Person result).Should().BeTrue();
-        result.Should().Be(new Person("David", 27));
+        Assert.True(db2.Database.TryGetValue("TEST", out Person result));
+        Assert.Equal(new Person("David", 27), result);
 
         // Cleanup
         File.Delete(db.Path);
@@ -84,8 +84,8 @@ public void Upsert() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetString("TEST", out string result).Should().BeTrue();
-        result.Should().Be("test");
+        Assert.True(db2.Database.TryGetString("TEST", out string result));
+        Assert.Equal("test", result);
 
         // Cleanup
         File.Delete(db.Path);
@@ -104,8 +104,8 @@ public void UpsertEncrypted() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetString("TEST", "enc", out string result).Should().BeTrue();
-        result.Should().Be("test");
+        Assert.True(db2.Database.TryGetString("TEST", "enc", out string result));
+        Assert.Equal("test", result);
 
         // Cleanup
         File.Delete(db.Path);
@@ -124,8 +124,8 @@ public void UpsertBytes() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValue("TEST", out var result).Should().BeTrue();
-        result.Span.SequenceEqual(bytes).Should().BeTrue();
+        Assert.True(db2.Database.TryGetValue("TEST", out var result));
+        Assert.Equal(bytes, result.Span);
 
         // Cleanup
         File.Delete(db.Path);
@@ -144,8 +144,8 @@ public void UpsertMemoryPackable() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValue<Person>("1", out var p2).Should().BeTrue();
-        p2.Should().Be(p1);
+        Assert.True(db2.Database.TryGetValue<Person>("1", out var p2));
+        Assert.Equal(p1, p2);
 
         // Cleanup
         File.Delete(db.Path);
@@ -159,14 +159,14 @@ public void UpsertMany() {
         // Act
         var p1 = new Person("David", 27);
         var p2 = new Person("John", 30);
-        db.Database.UpsertMany("1", new []{ p1, p2 });
+        db.Database.UpsertMany("1", [p1, p2]);
 
         // Arrange
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValues<Person>("1", out var arr).Should().BeTrue();
-        arr.Should().ContainInOrder(p1, p2);
+        Assert.True(db2.Database.TryGetValues<Person>("1", out var arr));
+        Assert.Equal([p1, p2], arr);
 
         // Cleanup
         File.Delete(db.Path);
@@ -190,8 +190,8 @@ public void UpsertJson() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValue("1", JsonContext.Default.Color, out var p2).Should().BeTrue();
-        p2.Should().Be(p1);
+        Assert.True(db2.Database.TryGetValue("1", JsonContext.Default.Color, out var p2));
+        Assert.Equal(p1, p2);
 
         // Cleanup
         File.Delete(db.Path);
@@ -212,12 +212,12 @@ public void GeneralFilterTest() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.ContainsKey("David").Should().BeFalse();
-        db2.Database.ContainsKey("Buddy").Should().BeFalse();
-        db.Database.CreateMemoryPackFilter<Person>().TryGetValue("DAVID", out var p2).Should().BeTrue();
-        db.Database.CreateMemoryPackFilter<Dog>().TryGetValue("BUDDY", out var d2).Should().BeTrue();
-        p2.Should().Be(p1);
-        d2.Should().Be(d1);
+        Assert.False(db2.Database.ContainsKey("David"));
+        Assert.False(db2.Database.ContainsKey("Buddy"));
+        Assert.True(db.Database.CreateMemoryPackFilter<Person>().TryGetValue("DAVID", out var p2));
+        Assert.True(db.Database.CreateMemoryPackFilter<Dog>().TryGetValue("BUDDY", out var d2));
+        Assert.Equal(p1, p2);
+        Assert.Equal(d1, d2);
 
         // Cleanup
         File.Delete(db.Path);
@@ -237,7 +237,7 @@ public async Task UpsertConcurrently() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.Count.Should().Be(100);
+        Assert.Equal(100, db2.Database.Count);
 
         // Cleanup
         File.Delete(db.Path);
@@ -252,7 +252,7 @@ public void Contains() {
         db.Database.Upsert("test", "test");
 
         // Assert
-        db.Database.ContainsKey("TEST").Should().BeTrue();
+        Assert.True(db.Database.ContainsKey("TEST"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -267,7 +267,7 @@ public void ContainsFiltered() {
         db.Database.CreateMemoryPackFilter<Person>().Upsert("test", new Person("David", 27));
 
         // Assert
-        db.Database.CreateMemoryPackFilter<Person>().ContainsKey("TEST").Should().BeTrue();
+        Assert.True(db.Database.CreateMemoryPackFilter<Person>().ContainsKey("TEST"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -283,7 +283,7 @@ public void Remove() {
         db.Database.Remove("test");
 
         // Assert
-        db.Database.ContainsKey("TEST").Should().BeFalse();
+        Assert.False(db.Database.ContainsKey("TEST"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -299,7 +299,7 @@ public void RemovePredicate() {
         db.Database.Remove(key => key == "test");
 
         // Assert
-        db.Database.ContainsKey("test").Should().BeFalse();
+        Assert.False(db.Database.ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -315,7 +315,7 @@ public void RemoveFiltered() {
         db.Database.CreateMemoryPackFilter<Person>().Remove("test");
 
         // Assert
-        db.Database.CreateMemoryPackFilter<Person>().ContainsKey("TEST").Should().BeFalse();
+        Assert.False(db.Database.CreateMemoryPackFilter<Person>().ContainsKey("TEST"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -331,7 +331,7 @@ public void RemoveFilteredPredicate() {
         db.Database.CreateMemoryPackFilter<Person>().Remove(key => key == "test");
 
         // Assert
-        db.Database.CreateMemoryPackFilter<Person>().ContainsKey("test").Should().BeFalse();
+        Assert.False(db.Database.CreateMemoryPackFilter<Person>().ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -347,7 +347,7 @@ public void Clear() {
         db.Database.Clear();
 
         // Assert
-        db.Database.ContainsKey("TEST").Should().BeFalse();
+        Assert.False(db.Database.ContainsKey("TEST"));
 
         // Cleanup
         File.Delete(db.Path);
diff --git a/tests/Sharpify.Data.Tests/DatabaseEncryptedTests.cs b/tests/Sharpify.Data.Tests/DatabaseEncryptedTests.cs
index abf95c6..2946a65 100644
--- a/tests/Sharpify.Data.Tests/DatabaseEncryptedTests.cs
+++ b/tests/Sharpify.Data.Tests/DatabaseEncryptedTests.cs
@@ -42,8 +42,8 @@ public void SerializeAndDeserialize() {
             EncryptionKey = "test"
         });
 
-        database2.TryGetValue("test", out Person result).Should().BeTrue();
-        result.Should().Be(new Person("David", 27));
+        Assert.True(database2.TryGetValue("test", out Person result));
+        Assert.Equal(new Person("David", 27), result);
     }
 
     [Fact]
@@ -60,8 +60,8 @@ public async Task AsyncSerializeDeserialize() {
         using var db2 = await AsyncFactory(db.Path);
 
         // Assert
-        db2.Database.TryGetValue("test", out Person result).Should().BeTrue();
-        result.Should().Be(new Person("David", 27));
+        Assert.True(db2.Database.TryGetValue("test", out Person result));
+        Assert.Equal(new Person("David", 27), result);
 
         // Cleanup
         File.Delete(db.Path);
@@ -80,8 +80,8 @@ public void Upsert() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetString("test", out string result).Should().BeTrue();
-        result.Should().Be("test");
+        Assert.True(db2.Database.TryGetString("test", out string result));
+        Assert.Equal("test", result);
 
         // Cleanup
         File.Delete(db.Path);
@@ -100,8 +100,8 @@ public void UpsertEncrypted() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetString("test", "enc", out string result).Should().BeTrue();
-        result.Should().Be("test");
+        Assert.True(db2.Database.TryGetString("test", "enc", out string result));
+        Assert.Equal("test", result);
 
         // Cleanup
         File.Delete(db.Path);
@@ -113,15 +113,15 @@ public void UpsertBytes() {
         using var db = Factory("");
 
         // Act
-        byte[] bytes = new byte[] { 1, 2, 3, 4, 5 };
+        byte[] bytes = [1, 2, 3, 4, 5];
         db.Database.Upsert("test", bytes);
 
         // Arrange
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValue("test", out var result).Should().BeTrue();
-        result.Span.SequenceEqual(bytes).Should().BeTrue();
+        Assert.True(db2.Database.TryGetValue("test", out var result));
+        Assert.Equal(bytes, result.Span);
 
         // Cleanup
         File.Delete(db.Path);
@@ -140,8 +140,8 @@ public void UpsertMemoryPackable() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValue<Person>("1", out var p2).Should().BeTrue();
-        p2.Should().Be(p1);
+        Assert.True(db2.Database.TryGetValue<Person>("1", out var p2));
+        Assert.Equal(p1, p2);
 
         // Cleanup
         File.Delete(db.Path);
@@ -155,14 +155,14 @@ public void UpsertMany() {
         // Act
         var p1 = new Person("David", 27);
         var p2 = new Person("John", 30);
-        db.Database.UpsertMany("1", new []{ p1, p2 });
+        db.Database.UpsertMany("1", [p1, p2]);
 
         // Arrange
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValues<Person>("1", out var arr).Should().BeTrue();
-        arr.Should().ContainInOrder(p1, p2);
+        Assert.True(db2.Database.TryGetValues<Person>("1", out var arr));
+        Assert.Equal([p1, p2], arr);
 
         // Cleanup
         File.Delete(db.Path);
@@ -186,8 +186,8 @@ public void UpsertJson() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValue("1", JsonContext.Default.Color, out var p2).Should().BeTrue();
-        p2.Should().Be(p1);
+        Assert.True(db2.Database.TryGetValue("1", JsonContext.Default.Color, out var p2));
+        Assert.Equal(p1, p2);
 
         // Cleanup
         File.Delete(db.Path);
@@ -208,12 +208,12 @@ public void GeneralFilterTest() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.ContainsKey("David").Should().BeFalse();
-        db2.Database.ContainsKey("Buddy").Should().BeFalse();
-        db.Database.CreateMemoryPackFilter<Person>().TryGetValue("David", out var p2).Should().BeTrue();
-        db.Database.CreateMemoryPackFilter<Dog>().TryGetValue("Buddy", out var d2).Should().BeTrue();
-        p2.Should().Be(p1);
-        d2.Should().Be(d1);
+        Assert.False(db2.Database.ContainsKey("David"));
+        Assert.False(db2.Database.ContainsKey("Buddy"));
+        Assert.True(db.Database.CreateMemoryPackFilter<Person>().TryGetValue("David", out var p2));
+        Assert.True(db.Database.CreateMemoryPackFilter<Dog>().TryGetValue("Buddy", out var d2));
+        Assert.Equal(p1, p2);
+        Assert.Equal(d1, d2);
 
         // Cleanup
         File.Delete(db.Path);
@@ -233,7 +233,7 @@ public async Task UpsertConcurrently() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.Count.Should().Be(100);
+        Assert.Equal(100, db2.Database.Count);
 
         // Cleanup
         File.Delete(db.Path);
@@ -248,7 +248,7 @@ public void Contains() {
         db.Database.Upsert("test", "test");
 
         // Assert
-        db.Database.ContainsKey("test").Should().BeTrue();
+        Assert.True(db.Database.ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -263,7 +263,7 @@ public void ContainsFiltered() {
         db.Database.CreateMemoryPackFilter<Person>().Upsert("test", new Person("David", 27));
 
         // Assert
-        db.Database.CreateMemoryPackFilter<Person>().ContainsKey("test").Should().BeTrue();
+        Assert.True(db.Database.CreateMemoryPackFilter<Person>().ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -279,7 +279,7 @@ public void Remove() {
         db.Database.Remove("test");
 
         // Assert
-        db.Database.ContainsKey("test").Should().BeFalse();
+        Assert.False(db.Database.ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -295,7 +295,7 @@ public void RemovePredicate() {
         db.Database.Remove(key => key == "test");
 
         // Assert
-        db.Database.ContainsKey("test").Should().BeFalse();
+        Assert.False(db.Database.ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -311,7 +311,7 @@ public void RemoveFiltered() {
         db.Database.CreateMemoryPackFilter<Person>().Remove("test");
 
         // Assert
-        db.Database.CreateMemoryPackFilter<Person>().ContainsKey("test").Should().BeFalse();
+        Assert.False(db.Database.CreateMemoryPackFilter<Person>().ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -327,7 +327,7 @@ public void RemoveFilteredPredicate() {
         db.Database.CreateMemoryPackFilter<Person>().Remove(key => key == "test");
 
         // Assert
-        db.Database.CreateMemoryPackFilter<Person>().ContainsKey("test").Should().BeFalse();
+        Assert.False(db.Database.CreateMemoryPackFilter<Person>().ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -343,7 +343,7 @@ public void Clear() {
         db.Database.Clear();
 
         // Assert
-        db.Database.ContainsKey("test").Should().BeFalse();
+        Assert.False(db.Database.ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
diff --git a/tests/Sharpify.Data.Tests/DatabaseIgnoreCaseTests.cs b/tests/Sharpify.Data.Tests/DatabaseIgnoreCaseTests.cs
index 5e8056b..607230e 100644
--- a/tests/Sharpify.Data.Tests/DatabaseIgnoreCaseTests.cs
+++ b/tests/Sharpify.Data.Tests/DatabaseIgnoreCaseTests.cs
@@ -45,8 +45,8 @@ public void SerializeAndDeserialize() {
             IgnoreCase = true,
         });
 
-        database2.TryGetValue("TEST", out Person result).Should().BeTrue();
-        result.Should().Be(new Person("David", 27));
+        Assert.True(database2.TryGetValue("TEST", out Person result));
+        Assert.Equal(new Person("David", 27), result);
     }
 
     [Fact]
@@ -63,8 +63,8 @@ public async Task AsyncSerializeDeserialize() {
         using var db2 = await AsyncFactory(db.Path);
 
         // Assert
-        db2.Database.TryGetValue("TEST", out Person result).Should().BeTrue();
-        result.Should().Be(new Person("David", 27));
+        Assert.True(db2.Database.TryGetValue("TEST", out Person result));
+        Assert.Equal(new Person("David", 27), result);
 
         // Cleanup
         File.Delete(db.Path);
@@ -83,8 +83,8 @@ public void Upsert() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetString("TEST", out string result).Should().BeTrue();
-        result.Should().Be("test");
+        Assert.True(db2.Database.TryGetString("TEST", out string result));
+        Assert.Equal("test", result);
 
         // Cleanup
         File.Delete(db.Path);
@@ -103,8 +103,8 @@ public void UpsertEncrypted() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetString("TEST", "enc", out string result).Should().BeTrue();
-        result.Should().Be("test");
+        Assert.True(db2.Database.TryGetString("TEST", "enc", out string result));
+        Assert.Equal("test", result);
 
         // Cleanup
         File.Delete(db.Path);
@@ -123,8 +123,8 @@ public void UpsertBytes() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValue("TEST", out var result).Should().BeTrue();
-        result.Span.SequenceEqual(bytes).Should().BeTrue();
+        Assert.True(db2.Database.TryGetValue("TEST", out var result));
+        Assert.Equal(bytes, result.Span);
 
         // Cleanup
         File.Delete(db.Path);
@@ -143,8 +143,8 @@ public void UpsertMemoryPackable() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValue<Person>("1", out var p2).Should().BeTrue();
-        p2.Should().Be(p1);
+        Assert.True(db2.Database.TryGetValue<Person>("1", out var p2));
+        Assert.Equal(p1, p2);
 
         // Cleanup
         File.Delete(db.Path);
@@ -158,14 +158,14 @@ public void UpsertMany() {
         // Act
         var p1 = new Person("David", 27);
         var p2 = new Person("John", 30);
-        db.Database.UpsertMany("1", new []{ p1, p2 });
+        db.Database.UpsertMany("1", [p1, p2]);
 
         // Arrange
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValues<Person>("1", out var arr).Should().BeTrue();
-        arr.Should().ContainInOrder(p1, p2);
+        Assert.True(db2.Database.TryGetValues<Person>("1", out var arr));
+        Assert.Equal([p1, p2], arr);
 
         // Cleanup
         File.Delete(db.Path);
@@ -189,8 +189,8 @@ public void UpsertJson() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValue("1", JsonContext.Default.Color, out var p2).Should().BeTrue();
-        p2.Should().Be(p1);
+        Assert.True(db2.Database.TryGetValue("1", JsonContext.Default.Color, out var p2));
+        Assert.Equal(p1, p2);
 
         // Cleanup
         File.Delete(db.Path);
@@ -211,12 +211,12 @@ public void GeneralFilterTest() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.ContainsKey("David").Should().BeFalse();
-        db2.Database.ContainsKey("Buddy").Should().BeFalse();
-        db.Database.CreateMemoryPackFilter<Person>().TryGetValue("DAVID", out var p2).Should().BeTrue();
-        db.Database.CreateMemoryPackFilter<Dog>().TryGetValue("BUDDY", out var d2).Should().BeTrue();
-        p2.Should().Be(p1);
-        d2.Should().Be(d1);
+        Assert.False(db2.Database.ContainsKey("David"));
+        Assert.False(db2.Database.ContainsKey("Buddy"));
+        Assert.True(db.Database.CreateMemoryPackFilter<Person>().TryGetValue("DAVID", out var p2));
+        Assert.True(db.Database.CreateMemoryPackFilter<Dog>().TryGetValue("BUDDY", out var d2));
+        Assert.Equal(p1, p2);
+        Assert.Equal(d1, d2);
 
         // Cleanup
         File.Delete(db.Path);
@@ -236,7 +236,7 @@ public async Task UpsertConcurrently() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.Count.Should().Be(100);
+        Assert.Equal(100, db2.Database.Count);
 
         // Cleanup
         File.Delete(db.Path);
@@ -251,7 +251,7 @@ public void Contains() {
         db.Database.Upsert("test", "test");
 
         // Assert
-        db.Database.ContainsKey("TEST").Should().BeTrue();
+        Assert.True(db.Database.ContainsKey("TEST"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -266,7 +266,7 @@ public void ContainsFiltered() {
         db.Database.CreateMemoryPackFilter<Person>().Upsert("test", new Person("David", 27));
 
         // Assert
-        db.Database.CreateMemoryPackFilter<Person>().ContainsKey("TEST").Should().BeTrue();
+        Assert.True(db.Database.CreateMemoryPackFilter<Person>().ContainsKey("TEST"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -282,7 +282,7 @@ public void Remove() {
         db.Database.Remove("test");
 
         // Assert
-        db.Database.ContainsKey("TEST").Should().BeFalse();
+        Assert.False(db.Database.ContainsKey("TEST"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -298,7 +298,7 @@ public void RemovePredicate() {
         db.Database.Remove(key => key == "test");
 
         // Assert
-        db.Database.ContainsKey("test").Should().BeFalse();
+        Assert.False(db.Database.ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -314,7 +314,7 @@ public void RemoveFiltered() {
         db.Database.CreateMemoryPackFilter<Person>().Remove("test");
 
         // Assert
-        db.Database.CreateMemoryPackFilter<Person>().ContainsKey("TEST").Should().BeFalse();
+        Assert.False(db.Database.CreateMemoryPackFilter<Person>().ContainsKey("TEST"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -330,7 +330,7 @@ public void RemoveFilteredPredicate() {
         db.Database.CreateMemoryPackFilter<Person>().Remove(key => key == "test");
 
         // Assert
-        db.Database.CreateMemoryPackFilter<Person>().ContainsKey("test").Should().BeFalse();
+        Assert.False(db.Database.CreateMemoryPackFilter<Person>().ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -346,7 +346,7 @@ public void Clear() {
         db.Database.Clear();
 
         // Assert
-        db.Database.ContainsKey("TEST").Should().BeFalse();
+        Assert.False(db.Database.ContainsKey("TEST"));
 
         // Cleanup
         File.Delete(db.Path);
diff --git a/tests/Sharpify.Data.Tests/DatabaseTests.cs b/tests/Sharpify.Data.Tests/DatabaseTests.cs
index bbc5152..aa88a88 100644
--- a/tests/Sharpify.Data.Tests/DatabaseTests.cs
+++ b/tests/Sharpify.Data.Tests/DatabaseTests.cs
@@ -43,8 +43,8 @@ public void SerializeAndDeserialize() {
             EncryptionKey = "test"
         });
 
-        database2.TryGetValue("test", out Person result).Should().BeTrue();
-        result.Should().Be(new Person("David", 27));
+        Assert.True(database2.TryGetValue("test", out Person result));
+        Assert.Equal(new Person("David", 27), result);
     }
 
     [Fact]
@@ -61,8 +61,8 @@ public async Task AsyncSerializeDeserialize() {
         using var db2 = await AsyncFactory(db.Path);
 
         // Assert
-        db2.Database.TryGetValue("test", out Person result).Should().BeTrue();
-        result.Should().Be(new Person("David", 27));
+        Assert.True(db2.Database.TryGetValue("test", out Person result));
+        Assert.Equal(new Person("David", 27), result);
 
         // Cleanup
         File.Delete(db.Path);
@@ -81,8 +81,8 @@ public void Upsert() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetString("test", out string result).Should().BeTrue();
-        result.Should().Be("test");
+        Assert.True(db2.Database.TryGetString("test", out string result));
+        Assert.Equal("test", result);
 
         // Cleanup
         File.Delete(db.Path);
@@ -101,8 +101,8 @@ public void UpsertEncrypted() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetString("test", "enc", out string result).Should().BeTrue();
-        result.Should().Be("test");
+        Assert.True(db2.Database.TryGetString("test", "enc", out string result));
+        Assert.Equal("test", result);
 
         // Cleanup
         File.Delete(db.Path);
@@ -114,15 +114,15 @@ public void UpsertBytes() {
         using var db = Factory("");
 
         // Act
-        byte[] bytes = new byte[] { 1, 2, 3, 4, 5 };
+        byte[] bytes = [1, 2, 3, 4, 5];
         db.Database.Upsert("test", bytes);
 
         // Arrange
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValue("test", out var result).Should().BeTrue();
-        result.Span.SequenceEqual(bytes).Should().BeTrue();
+        Assert.True(db2.Database.TryGetValue("test", out var result));
+        Assert.Equal(bytes, result.Span);
 
         // Cleanup
         File.Delete(db.Path);
@@ -145,8 +145,8 @@ public void SpanBasedByteReadWrite() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValue("test", out var result).Should().BeTrue();
-        result.Span.SequenceEqual<byte>([1, 2, 3, 4, 5, 6]).Should().BeTrue();
+        Assert.True(db2.Database.TryGetValue("test", out var result));
+        Assert.Equal(new byte[] { 1, 2, 3, 4, 5, 6 }, result.Span);
 
         // Cleanup
         File.Delete(db.Path);
@@ -167,8 +167,8 @@ public void UpsertMemoryPackable() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValue<Person>("1", out var p2).Should().BeTrue();
-        p2.Should().Be(p1);
+        Assert.True(db2.Database.TryGetValue<Person>("1", out var p2));
+        Assert.Equal(p1, p2);
 
         // Cleanup
         File.Delete(db.Path);
@@ -182,14 +182,14 @@ public void UpsertMany() {
         // Act
         var p1 = new Person("David", 27);
         var p2 = new Person("John", 30);
-        db.Database.UpsertMany("1", new []{ p1, p2 });
+        db.Database.UpsertMany("1", [p1, p2]);
 
         // Arrange
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValues<Person>("1", out var arr).Should().BeTrue();
-        arr.Should().ContainInOrder(p1, p2);
+        Assert.True(db2.Database.TryGetValues<Person>("1", out var arr));
+        Assert.Equal([p1, p2], arr);
 
         // Cleanup
         File.Delete(db.Path);
@@ -210,8 +210,8 @@ public void UpsertManySpan() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValues<Person>("1", out var arr).Should().BeTrue();
-        arr.Should().ContainInOrder(p1, p2);
+        Assert.True(db2.Database.TryGetValues<Person>("1", out var arr));
+        Assert.Equal([p1, p2], arr);
 
         // Cleanup
         File.Delete(db.Path);
@@ -237,8 +237,8 @@ public void SpanBasedTReadWrite() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValues<Person>("1", out var arr).Should().BeTrue();
-        arr.Should().ContainInOrder(p1, p2, p3);
+        Assert.True(db2.Database.TryGetValues<Person>("1", out var arr));
+        Assert.Equal([p1, p2, p3], arr);
 
         // Cleanup
         File.Delete(db.Path);
@@ -262,8 +262,8 @@ public void UpsertJson() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.TryGetValue("1", JsonContext.Default.Color, out var p2).Should().BeTrue();
-        p2.Should().Be(p1);
+        Assert.True(db2.Database.TryGetValue("1", JsonContext.Default.Color, out var p2));
+        Assert.Equal(p1, p2);
 
         // Cleanup
         File.Delete(db.Path);
@@ -284,12 +284,12 @@ public void GeneralFilterTest() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.ContainsKey("David").Should().BeFalse();
-        db2.Database.ContainsKey("Buddy").Should().BeFalse();
-        db.Database.CreateMemoryPackFilter<Person>().TryGetValue("David", out var p2).Should().BeTrue();
-        db.Database.CreateMemoryPackFilter<Dog>().TryGetValue("Buddy", out var d2).Should().BeTrue();
-        p2.Should().Be(p1);
-        d2.Should().Be(d1);
+        Assert.False(db2.Database.ContainsKey("David"));
+        Assert.False(db2.Database.ContainsKey("Buddy"));
+        Assert.True(db.Database.CreateMemoryPackFilter<Person>().TryGetValue("David", out var p2));
+        Assert.True(db.Database.CreateMemoryPackFilter<Dog>().TryGetValue("Buddy", out var d2));
+        Assert.Equal(p1, p2);
+        Assert.Equal(d1, d2);
 
         // Cleanup
         File.Delete(db.Path);
@@ -309,7 +309,7 @@ public async Task UpsertConcurrently() {
         using var db2 = Factory(db.Path);
 
         // Assert
-        db2.Database.Count.Should().Be(100);
+        Assert.Equal(100, db2.Database.Count);
 
         // Cleanup
         File.Delete(db.Path);
@@ -324,7 +324,7 @@ public void Contains() {
         db.Database.Upsert("test", "test");
 
         // Assert
-        db.Database.ContainsKey("test").Should().BeTrue();
+        Assert.True(db.Database.ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -339,7 +339,7 @@ public void ContainsFiltered() {
         db.Database.CreateMemoryPackFilter<Person>().Upsert("test", new Person("David", 27));
 
         // Assert
-        db.Database.CreateMemoryPackFilter<Person>().ContainsKey("test").Should().BeTrue();
+        Assert.True(db.Database.CreateMemoryPackFilter<Person>().ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -355,7 +355,7 @@ public void Remove() {
         db.Database.Remove("test");
 
         // Assert
-        db.Database.ContainsKey("test").Should().BeFalse();
+        Assert.False(db.Database.ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -371,7 +371,7 @@ public void RemovePredicate() {
         db.Database.Remove(key => key == "test");
 
         // Assert
-        db.Database.ContainsKey("test").Should().BeFalse();
+        Assert.False(db.Database.ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -387,7 +387,7 @@ public void RemoveFiltered() {
         db.Database.CreateMemoryPackFilter<Person>().Remove("test");
 
         // Assert
-        db.Database.CreateMemoryPackFilter<Person>().ContainsKey("test").Should().BeFalse();
+        Assert.False(db.Database.CreateMemoryPackFilter<Person>().ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -403,7 +403,7 @@ public void RemoveFilteredPredicate() {
         db.Database.CreateMemoryPackFilter<Person>().Remove(key => key == "test");
 
         // Assert
-        db.Database.CreateMemoryPackFilter<Person>().ContainsKey("test").Should().BeFalse();
+        Assert.False(db.Database.CreateMemoryPackFilter<Person>().ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
@@ -419,7 +419,7 @@ public void Clear() {
         db.Database.Clear();
 
         // Assert
-        db.Database.ContainsKey("test").Should().BeFalse();
+        Assert.False(db.Database.ContainsKey("test"));
 
         // Cleanup
         File.Delete(db.Path);
diff --git a/tests/Sharpify.Data.Tests/GlobalUsings.cs b/tests/Sharpify.Data.Tests/GlobalUsings.cs
index 7fef4b0..8c927eb 100644
--- a/tests/Sharpify.Data.Tests/GlobalUsings.cs
+++ b/tests/Sharpify.Data.Tests/GlobalUsings.cs
@@ -1,2 +1 @@
-global using Xunit;
-global using FluentAssertions;
\ No newline at end of file
+global using Xunit;
\ No newline at end of file
diff --git a/tests/Sharpify.Data.Tests/HelperTests.cs b/tests/Sharpify.Data.Tests/HelperTests.cs
index 1ad17ab..77c985e 100644
--- a/tests/Sharpify.Data.Tests/HelperTests.cs
+++ b/tests/Sharpify.Data.Tests/HelperTests.cs
@@ -15,7 +15,7 @@ public class HelperTests {
 	public void GetRequiredLength_Unmanaged<T>(T[] data, int expectedLength) {
 		var serialized = MemoryPackSerializer.Serialize(data);
 		var requiredLength = Helper.GetRequiredLength(serialized);
-		requiredLength.Should().Be(expectedLength);
+		Assert.Equal(expectedLength, requiredLength);
 	}
 
 	[Fact]
@@ -24,7 +24,7 @@ public void GetRequiredLength_Person() {
 		var data = Enumerable.Range(1, faker.Random.Int(10, 100)).Select(_ => new Person(faker.Name.FullName(), faker.Random.Int(1, 100))).ToArray();
 		var serialized = MemoryPackSerializer.Serialize(data);
 		var requiredLength = Helper.GetRequiredLength(serialized);
-		requiredLength.Should().Be(data.Length);
+		Assert.Equal(data.Length, requiredLength);
 	}
 
 	[Theory]
@@ -38,7 +38,7 @@ public void ReadToRentedBufferWriter_Unmanaged<T>(T[] data, int expectedLength)
 		var buffer = new RentedBufferWriter<T>(requiredLength + 5);
 		try {
 			Helper.ReadToRenterBufferWriter(ref buffer, serialized, requiredLength);
-			buffer.Position.Should().Be(expectedLength);
+			Assert.Equal(expectedLength, buffer.Position);
 		} finally {
 			buffer?.Dispose();
 		}
@@ -53,7 +53,7 @@ public void ReadToRentedBufferWriter_Person() {
 		var buffer = new RentedBufferWriter<Person>(requiredLength + 5);
 		try {
 			Helper.ReadToRenterBufferWriter(ref buffer, serialized, requiredLength);
-			buffer.Position.Should().Be(requiredLength);
+			Assert.Equal(requiredLength, buffer.Position);
 		} finally {
 			buffer?.Dispose();
 		}
diff --git a/tests/Sharpify.Data.Tests/Sharpify.Data.Tests.csproj b/tests/Sharpify.Data.Tests/Sharpify.Data.Tests.csproj
index b551f65..987cc84 100644
--- a/tests/Sharpify.Data.Tests/Sharpify.Data.Tests.csproj
+++ b/tests/Sharpify.Data.Tests/Sharpify.Data.Tests.csproj
@@ -12,14 +12,13 @@
 
     <ItemGroup>
         <PackageReference Include="Bogus" Version="35.6.1" />
-        <PackageReference Include="FluentAssertions" Version="6.12.2" />
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
-        <PackageReference Include="xunit" Version="2.9.2" />
-        <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+        <PackageReference Include="xunit" Version="2.9.3" />
+        <PackageReference Include="xunit.runner.visualstudio" Version="3.0.1">
           <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
           <PrivateAssets>all</PrivateAssets>
         </PackageReference>
-        <PackageReference Include="coverlet.collector" Version="6.0.2">
+        <PackageReference Include="coverlet.collector" Version="6.0.3">
           <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
           <PrivateAssets>all</PrivateAssets>
         </PackageReference>
diff --git a/tests/Sharpify.Tests/AesProviderTests.cs b/tests/Sharpify.Tests/AesProviderTests.cs
index 29ac100..e1f9e1f 100644
--- a/tests/Sharpify.Tests/AesProviderTests.cs
+++ b/tests/Sharpify.Tests/AesProviderTests.cs
@@ -12,7 +12,7 @@ public void AesProvider_PlainText() {
         string encrypted = aesProvider.Encrypt(PlainText);
         string decrypted = aesProvider.Decrypt(encrypted);
 
-        decrypted.Should().Be(PlainText);
+        Assert.Equal(PlainText, decrypted);
     }
 
     [Fact]
@@ -23,7 +23,7 @@ public void AesProvider_Bytes() {
         byte[] encryptedBytes = aesProvider.EncryptBytes(plainBytes);
         byte[] decryptedBytes = aesProvider.DecryptBytes(encryptedBytes);
 
-        decryptedBytes.Should().Equal(plainBytes);
+        Assert.Equal(plainBytes, decryptedBytes);
     }
 
     [Fact]
@@ -35,7 +35,7 @@ public void AesProvider_Bytes_Span() {
         Span<byte> decryptedSpan = stackalloc byte[plainBytes.Length];
         int written = aesProvider.DecryptBytes(encryptedBytes, decryptedSpan, true);
 
-        decryptedSpan.Slice(0, written).SequenceEqual(plainBytes).Should().BeTrue();
+        Assert.Equal(plainBytes, decryptedSpan.Slice(0, written));
     }
 
     [Fact]
@@ -45,7 +45,7 @@ public void AesProvider_DecryptBytes_WhenInputIsNotEncrypted_ReturnsEmptyString(
         using var aesProvider = new AesProvider(Key);
         byte[] decryptedBytes = aesProvider.DecryptBytes(plainBytes);
 
-        decryptedBytes.Should().Equal(Array.Empty<byte>());
+        Assert.Equal(Array.Empty<byte>(), decryptedBytes);
     }
 
     [Fact]
@@ -54,7 +54,7 @@ public void AesProvider_GeneratePassword_AndValidate() {
         string hashedPassword = AesProvider.GeneratePassword(password);
         bool isValid = AesProvider.IsPasswordValid(password, hashedPassword);
 
-        isValid.Should().BeTrue();
+        Assert.True(isValid);
     }
 
     [Fact]
@@ -64,7 +64,7 @@ public void AesProvider_Validate_Invalid() {
         string hashedPassword = AesProvider.GeneratePassword(password);
         bool isValid = AesProvider.IsPasswordValid(wrongPassword, hashedPassword);
 
-        isValid.Should().BeFalse();
+        Assert.False(isValid);
     }
 
     [Fact]
@@ -77,8 +77,8 @@ public void AesProvider_URL() {
             string copy = new(url);
             string encryptedUrl = aesProvider.EncryptUrl(url);
             string decryptedUrl = aesProvider.DecryptUrl(encryptedUrl);
-            url.Should().Be(copy);
-            decryptedUrl.Should().Be(url);
+            Assert.Equal(copy, url);
+            Assert.Equal(url, decryptedUrl);
         }
     }
 
@@ -92,8 +92,9 @@ public void AesProvider_EncryptUrl_OnPlainText() {
         var encryptedUrl = aesProvider.EncryptUrl(plainUrl);
 
         // Assert
-        encryptedUrl.Should().NotBeNullOrEmpty();
-        encryptedUrl.Should().NotBe(plainUrl);
+        Assert.NotNull(encryptedUrl);
+        Assert.NotEmpty(encryptedUrl);
+        Assert.NotEqual(plainUrl, encryptedUrl);
     }
 
     [Fact]
@@ -107,8 +108,9 @@ public void AesProvider_DecryptUrl_OnEncryptedText() {
         var decryptedUrl = aesProvider.DecryptUrl(encryptedUrl);
 
         // Assert
-        decryptedUrl.Should().NotBeNullOrEmpty();
-        decryptedUrl.Should().Be(plainUrl);
+        Assert.NotNull(decryptedUrl);
+        Assert.NotEmpty(decryptedUrl);
+        Assert.Equal(plainUrl, decryptedUrl);
     }
 
     [Fact]
@@ -122,8 +124,8 @@ public void AesProvider_DecryptUrl_IncorrectEncryptedUrl() {
         var decryptedUrl = aesProvider.DecryptUrl(incorrectEncryptedUrl);
 
         // Assert
-        decryptedUrl.Should().NotBeNull();
-        decryptedUrl.Should().NotBe(plainUrl);
+        Assert.NotNull(decryptedUrl);
+        Assert.NotEqual(plainUrl, decryptedUrl);
     }
 
     [Fact]
@@ -137,8 +139,9 @@ public void AesProvider_EncryptAndDecryptUrl_WhenInputIsUnicode() {
         var decryptedUrl = aesProvider.DecryptUrl(encryptedUrl);
 
         // Assert
-        decryptedUrl.Should().NotBeNullOrEmpty();
-        decryptedUrl.Should().Be(unicodeUrl);
+        Assert.NotNull(decryptedUrl);
+        Assert.NotEmpty(decryptedUrl);
+        Assert.Equal(unicodeUrl, decryptedUrl);
     }
 
     [Fact]
@@ -146,12 +149,12 @@ public void AesProvider_CreateEncryptor() {
         using var aesProvider = new AesProvider(Key);
         var encryptor = aesProvider.CreateEncryptor();
 
-        encryptor.Should().NotBeNull();
+        Assert.NotNull(encryptor);
 
         var actual = encryptor.TransformFinalBlock(Encoding.UTF8.GetBytes(PlainText), 0, PlainText.Length);
         var expected = aesProvider.EncryptBytes(Encoding.UTF8.GetBytes(PlainText));
 
-        actual.Should().BeEquivalentTo(expected);
+        Assert.Equal(expected, actual);
     }
 
     [Fact]
@@ -164,6 +167,6 @@ public void AesProvider_CreateDecryptor() {
         var actual = decryptor.TransformFinalBlock(source, 0, source.Length);
         var expected = aesProvider.DecryptBytes(source);
 
-        actual.Should().BeEquivalentTo(expected);
+        Assert.Equal(expected, actual);
     }
 }
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/CollectionExtensionsTests.cs b/tests/Sharpify.Tests/CollectionExtensionsTests.cs
index dbc287c..217553e 100644
--- a/tests/Sharpify.Tests/CollectionExtensionsTests.cs
+++ b/tests/Sharpify.Tests/CollectionExtensionsTests.cs
@@ -12,7 +12,7 @@ public void IsNullOrEmpty_GivenNullList() {
         var result = list.IsNullOrEmpty();
 
         // Assert
-        result.Should().BeTrue();
+        Assert.True(result);
     }
 
     [Fact]
@@ -24,7 +24,7 @@ public void IsNullOrEmpty_GivenEmptyList() {
         var result = list.IsNullOrEmpty();
 
         // Assert
-        result.Should().BeTrue();
+        Assert.True(result);
     }
 
     [Fact]
@@ -36,9 +36,9 @@ public void AsSpan_GivenNonEmptyList_ReturnsCorrectSpan() {
         var span = list.AsSpan();
 
         // Assert
-        span.Length.Should().Be(list.Count);
+        Assert.Equal(list.Count, span.Length);
         for (int i = 0; i < list.Count; i++) {
-            span[i].Should().Be(list[i]);
+            Assert.Equal(list[i], span[i]);
         }
     }
 
@@ -51,7 +51,7 @@ public void AsSpan_GivenEmptyList_ReturnsEmptySpan() {
         var span = list.AsSpan();
 
         // Assert
-        span.Length.Should().Be(0);
+        Assert.Equal(0, span.Length);
     }
 
     [Fact]
@@ -70,7 +70,7 @@ public void GetValueRefOrNullRef_GivenExistingKey_ReturnsRefToValue() {
         ref var valueReal = ref CollectionsMarshal.GetValueRefOrNullRef(dictionary, key);
 
         // Assert
-        Unsafe.AreSame(ref valueRef, ref valueReal).Should().BeTrue();
+        Assert.True(Unsafe.AreSame(ref valueRef, ref valueReal));
     }
 
     [Fact]
@@ -83,7 +83,7 @@ public void GetValueRefOrNullRef_GivenNonExistingKey_ReturnsRefNull() {
         ref var valueRef = ref dictionary.GetValueRefOrNullRef(key);
 
         // Assert
-        Unsafe.IsNullRef(ref valueRef).Should().BeTrue();
+        Assert.True(Unsafe.IsNullRef(ref valueRef));
     }
 
     [Fact]
@@ -101,8 +101,8 @@ public void GetValueRefOrAddDefault_GivenExistingKey_ReturnsRefToValueAndDoesNot
         ref var valueRef = ref dictionary.GetValueRefOrAddDefault(key, out bool exists);
 
         // Assert
-        valueRef.Should().BeEquivalentTo("two");
-        exists.Should().BeTrue();
+        Assert.Equal("two", valueRef);
+        Assert.True(exists);
     }
 
     [Fact]
@@ -116,9 +116,9 @@ public void GetValueRefOrAddDefault_GivenNonExistingKey_AddsNewEntryWithDefaultV
 
         // Assert
         #pragma warning disable
-        valueRef.Should().Be(default(string));
-        exists.Should().BeFalse();
-        dictionary.Should().ContainKey(key).And.ContainValue(default(string));
+        Assert.Equal(default(string), valueRef);
+        Assert.False(exists);
+        Assert.Contains(new KeyValuePair<int, string>(key, default(string)), dictionary);
         #pragma warning restore
     }
 
@@ -128,7 +128,7 @@ public void CopyTo_CopiesDictionaryEntries() {
         var buffer = ArrayPool<KeyValuePair<int, int>>.Shared.Rent(dict.Count);
         dict.CopyTo(buffer, 0);
         var span = new Span<KeyValuePair<int, int>>(buffer, 0, dict.Count);
-        span.ToArray().Should().Equal(dict);
+        Assert.Equal(dict, span.ToArray());
         buffer.ReturnBufferToSharedArrayPool();
     }
 
@@ -137,7 +137,7 @@ public void RentBufferAndCopyEntries_ReturnRentedBuffer_Dictionary() {
         var dict = Enumerable.Range(1, 10).ToDictionary(i => i, i => i);
         var (buffer, entries) = dict.RentBufferAndCopyEntries();
         try {
-            entries.ToArray().Should().Equal(dict);
+            Assert.Equal(dict, entries.ToArray());
         } finally {
             buffer.ReturnBufferToSharedArrayPool();
         }
@@ -150,7 +150,7 @@ public void Dictionary_CopyToArray() {
         dict.CopyTo(buffer, 0);
         var span = buffer.AsSpan(0, dict.Count);
         try {
-            span.SequenceEqual(dict.ToArray()).Should().BeTrue();
+            Assert.Equal(dict, span.ToArray());
         } finally {
             buffer.ReturnBufferToSharedArrayPool();
         }
@@ -166,7 +166,7 @@ public void PureSort_GivenUnsortedIntArray_ReturnsSortedIntArray() {
         var result = source.PureSort(Comparer<int>.Default);
 
         // Assert
-        result.Should().Equal(expected);
+        Assert.Equal(expected, result);
     }
 
     [Fact]
@@ -179,7 +179,7 @@ public void PureSort_GivenUnsortedStringArray_ReturnsSortedStringArray() {
         var result = source.PureSort(StringComparer.InvariantCulture);
 
         // Assert
-        result.Should().Equal(expected);
+        Assert.Equal(expected, result);
     }
 
     [Fact]
@@ -192,7 +192,7 @@ public void PureSort_GivenUnsortedIntList_ReturnsSortedIntList() {
         var result = source.PureSort(Comparer<int>.Default);
 
         // Assert
-        result.Should().Equal(expected);
+        Assert.Equal(expected, result);
     }
 
     [Fact]
@@ -205,7 +205,7 @@ public void PureSort_GivenUnsortedStringList_ReturnsSortedStringList() {
         var result = source.PureSort(Comparer<string>.Default);
 
         // Assert
-        result.Should().Equal(expected);
+        Assert.Equal(expected, result);
     }
 
     [Fact]
@@ -218,7 +218,7 @@ public void RemoveDuplicates_GivenListWithDuplicates_RemovesDuplicates() {
         list.RemoveDuplicates();
 
         // Assert
-        list.Should().Equal(expected);
+        Assert.Equal(expected, list);
     }
 
     [Fact]
@@ -231,8 +231,8 @@ public void RemoveDuplicatesWithHashSet_GivenListWithDuplicates_RemovesDuplicate
         list.RemoveDuplicates(out var hSet);
 
         // Assert
-        list.Should().Equal(expected);
-        hSet.Should().HaveCount(expected.Count);
+        Assert.Equal(expected, list);
+        Assert.Equal(expected.Count, hSet.Count);
     }
 
     [Fact]
@@ -245,7 +245,7 @@ public void RemoveDuplicates_GivenListWithNoDuplicates_DoesNotModifyList() {
         list.RemoveDuplicates(comparer: StringComparer.InvariantCulture);
 
         // Assert
-        list.Should().Equal(expected);
+        Assert.Equal(expected, list);
     }
 
     [Fact]
@@ -258,7 +258,7 @@ public void RemoveDuplicates_Sorted_GivenSortedListWithDuplicates_RemovesDuplica
         list.RemoveDuplicates(isSorted: true);
 
         // Assert
-        list.Should().Equal(expected);
+        Assert.Equal(expected, list);
     }
 
     [Fact]
@@ -271,7 +271,7 @@ public void RemoveDuplicates_Sorted_GivenSortedListWithNoDuplicates_DoesNotModif
         list.RemoveDuplicates(isSorted: true, comparer: StringComparer.InvariantCulture);
 
         // Assert
-        list.Should().Equal(expected);
+        Assert.Equal(expected, list);
     }
 
     [Fact]
@@ -283,7 +283,7 @@ public void ChunkToSegments_GivenEmptyArray_ReturnsEmptyList() {
         var result = array.ChunkToSegments(3);
 
         // Assert
-        result.Should().BeEmpty();
+        Assert.Empty(result);
     }
 
     [Fact]
@@ -295,8 +295,8 @@ public void ChunkToSegments_GivenArrayWithLengthLessThanSegmentSize_ReturnsSingl
         var result = array.ChunkToSegments(5);
 
         // Assert
-        result.Should().HaveCount(1);
-        result[0].Should().Equal(array);
+        Assert.Single(result);
+        Assert.Equal(array, result[0]);
     }
 
     [Fact]
@@ -308,7 +308,7 @@ public void ChunkToSegments_GivenValidArray_ReturnsCorrectNumberOfSegments() {
         var result = array.ChunkToSegments(3);
 
         // Assert
-        result.Should().HaveCount(3);
-        result.Sum(s => s.Count).Should().Be(array.Length);
+        Assert.Equal(3, result.Count);
+        Assert.Equal(array.Length, result.Sum(s => s.Count));
     }
 }
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/Collections/BufferWrapperTests.cs b/tests/Sharpify.Tests/Collections/BufferWrapperTests.cs
index 23b4592..0daac5a 100644
--- a/tests/Sharpify.Tests/Collections/BufferWrapperTests.cs
+++ b/tests/Sharpify.Tests/Collections/BufferWrapperTests.cs
@@ -13,7 +13,7 @@ public void BufferWrapper_NoCapacity_Throws() {
         };
 
         // Act & Assert
-        act.Should().Throw<ArgumentOutOfRangeException>();
+        Assert.Throws<ArgumentOutOfRangeException>(act);
     }
 
     [Fact]
@@ -28,7 +28,7 @@ public void BufferWrapper_Append_ToFullCapacity() {
         };
 
         // Assert
-        act.Should().NotThrow<ArgumentOutOfRangeException>();
+        act();
     }
 
     [Fact]
@@ -43,7 +43,7 @@ public void BufferWrapper_Append_BeyondCapacity() {
         };
 
         // Assert
-        act.Should().Throw<ArgumentOutOfRangeException>();
+        Assert.Throws<ArgumentOutOfRangeException>(act);
     }
 
     [Fact]
@@ -57,7 +57,7 @@ public void BufferWrapper_Reset() {
         buffer.Append("David");
 
         // Assert
-        (buffer.WrittenSpan is "David").Should().BeTrue();
+        Assert.Equal("David", buffer.WrittenSpan);
     }
 }
 #endif
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/Collections/LazyLocalPersistentDictionaryTests.cs b/tests/Sharpify.Tests/Collections/LazyLocalPersistentDictionaryTests.cs
index 3894e80..172dc1c 100644
--- a/tests/Sharpify.Tests/Collections/LazyLocalPersistentDictionaryTests.cs
+++ b/tests/Sharpify.Tests/Collections/LazyLocalPersistentDictionaryTests.cs
@@ -18,7 +18,7 @@ public void LazyLocalPersistentDictionary_ReadKey_Null_WhenDoesNotExist() {
         var result = dict["test"];
 
         // Assert
-        result.Should().BeNull();
+        Assert.Null(result);
     }
 
     [Fact]
@@ -40,6 +40,6 @@ public async Task LazyLocalPersistentDictionary_ReadKey_Valid_WhenExists() {
         await dict.UpsertAsync("two", "2");
 
         // Assert
-        dict["two"].Should().Be("2");
+        Assert.Equal("2", dict["two"]);
     }
 }
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/Collections/LocalPersistentDictionaryTests.cs b/tests/Sharpify.Tests/Collections/LocalPersistentDictionaryTests.cs
index 3937f82..89fb2a6 100644
--- a/tests/Sharpify.Tests/Collections/LocalPersistentDictionaryTests.cs
+++ b/tests/Sharpify.Tests/Collections/LocalPersistentDictionaryTests.cs
@@ -24,7 +24,7 @@ public void LocalPersistentDictionary_ReadKey_Null_WhenDoesNotExist() {
         var result = dict["test"];
 
         // Assert
-        result.Should().BeNull();
+        Assert.Null(result);
     }
 
     [Fact]
@@ -40,7 +40,7 @@ public async Task LocalPersistentDictionary_ReadKey_Valid_WhenExists() {
         await dict.UpsertAsync("one", "1");
 
         // Assert
-        dict["one"].Should().Be("1");
+        Assert.Equal("1", dict["one"]);
     }
 
     [Fact]
@@ -57,8 +57,8 @@ public async Task LocalPersistentDictionary_GetOrCreate() {
         var check = dict["one"] is "1";
 
         // Assert
-        result.Should().Be("1");
-        check.Should().BeTrue();
+        Assert.Equal("1", result);
+        Assert.True(check);
     }
 
     [Fact]
@@ -88,7 +88,7 @@ public async Task LocalPersistentDictionary_Upsert_Concurrent() {
         // Ideally with perfectly concurrent updates, the dictionary would only be serialized once.
         // The reason not to check for 1 is that the tasks may not be executed perfectly in parallel.
         var sdict = new LocalPersistentDictionary(path);
-        sdict.Count.Should().Be(upsertTasks.Length);
+        Assert.Equal(upsertTasks.Length, sdict.Count);
         File.Delete(path);
     }
 
@@ -111,7 +111,7 @@ public async Task LocalPersistentDictionary_Upsert_Sequential_NoItemsMissing() {
 
         // Assert
         var sdict = new LocalPersistentDictionary(path);
-        sdict.Count.Should().Be(5);
+        Assert.Equal(5, sdict.Count);
         File.Delete(path);
     }
 
@@ -133,8 +133,8 @@ public async Task LocalPersistentDictionary_GenericGetAndUpsert() {
         int two = await sdict.GetOrCreateAsync("two", 0);
 
         // Assert
-        one.Should().Be(1);
-        two.Should().Be(2);
+        Assert.Equal(1, one);
+        Assert.Equal(2, two);
         File.Delete(path);
     }
 }
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/Collections/RentedBufferWriterTests.cs b/tests/Sharpify.Tests/Collections/RentedBufferWriterTests.cs
index 40951d7..24624d6 100644
--- a/tests/Sharpify.Tests/Collections/RentedBufferWriterTests.cs
+++ b/tests/Sharpify.Tests/Collections/RentedBufferWriterTests.cs
@@ -11,7 +11,7 @@ public void RentedBufferWriter_InvalidCapacity_Throws() {
         };
 
         // Act & Assert
-        act.Should().Throw<ArgumentOutOfRangeException>();
+        Assert.Throws<ArgumentOutOfRangeException>(act);
     }
 
     [Fact]
@@ -20,7 +20,7 @@ public void RentedBufferWriter_Capacity0IsDisabled() {
         using var buffer = new RentedBufferWriter<char>(0);
 
         // Assert
-        buffer.IsDisabled.Should().BeTrue();
+        Assert.True(buffer.IsDisabled);
     }
 
     [Fact]
@@ -34,7 +34,7 @@ public void RentedBufferWriter_WriteToSpan() {
         buffer.Advance(5);
 
         // Assert
-        buffer.WrittenSpan.SequenceEqual("Hello").Should().BeTrue();
+        Assert.Equal("Hello", buffer.WrittenSpan);
     }
 
     [Fact]
@@ -46,7 +46,7 @@ public void RentedBufferWriter_WriteAndAdvance() {
         buffer.WriteAndAdvance("Hello");
 
         // Assert
-        buffer.WrittenSpan.SequenceEqual("Hello").Should().BeTrue();
+        Assert.Equal("Hello", buffer.WrittenSpan);
     }
 
     [Fact]
@@ -60,7 +60,7 @@ public void RentedBufferWriter_UseRefToWriteValue() {
         buffer.Advance(length);
 
         // Assert
-        buffer.WrittenSpan.SequenceEqual([1, 1, 1, 1, 1]).Should().BeTrue();
+        Assert.Equal([1, 1, 1, 1, 1], buffer.WrittenSpan);
 
         static int WriteOnes(ref int[] buffer, int length) {
             for (var i = 0; i < length; i++) {
@@ -82,7 +82,7 @@ public void RentedBufferWriter_GetSpanSlice() {
         buffer.Advance(5);
 
         // Assert
-        buffer.GetSpanSlice(0, 3).SequenceEqual("Hel").Should().BeTrue();
+        Assert.Equal("Hel", buffer.GetSpanSlice(0, 3));
     }
 
     [Fact]
@@ -96,7 +96,7 @@ public void RentedBufferWriter_WriteToMemory() {
         buffer.Advance(5);
 
         // Assert
-        buffer.WrittenSegment.SequenceEqual("Hello").Should().BeTrue();
+        Assert.Equal("Hello".ToCharArray(), buffer.WrittenSegment);
     }
 
     [Fact]
@@ -110,7 +110,7 @@ public void RentedBufferWriter_GetMemorySlice() {
         buffer.Advance(5);
 
         // Assert
-        buffer.GetMemorySlice(0, 3).Span.SequenceEqual("Hel").Should().BeTrue();
+        Assert.Equal("Hello", buffer.GetMemorySlice(0, 5).Span);
     }
 
     [Fact]
@@ -124,7 +124,7 @@ public void RentedBufferWriter_WrittenSegment() {
         buffer.Advance(5);
 
         // Assert
-        buffer.WrittenSegment.SequenceEqual("Hello").Should().BeTrue();
+        Assert.Equal("Hello".ToCharArray(), buffer.WrittenSegment);
     }
 
     [Fact]
@@ -139,7 +139,7 @@ public void RentedBufferWriter_Reset() {
         buffer.Reset();
 
         // Assert
-        buffer.WrittenSpan.SequenceEqual(ReadOnlySpan<char>.Empty).Should().BeTrue();
+        Assert.Equal(ReadOnlySpan<char>.Empty, buffer.WrittenSpan);
     }
 
     [Fact]
@@ -148,7 +148,7 @@ public void RentedBufferWriter_ActualCapacity() {
         using var buffer = new RentedBufferWriter<char>(20);
 
         // Assert
-        buffer.ActualCapacity.Should().BeGreaterThanOrEqualTo(20);
+        Assert.True(buffer.ActualCapacity >= 20);
     }
 
     [Fact]
@@ -162,6 +162,6 @@ public void RentedBufferWriter_FreeCapacity() {
         buffer.Advance(5);
 
         // Assert
-        buffer.FreeCapacity.Should().BeGreaterThanOrEqualTo(15);
+        Assert.True(buffer.FreeCapacity >= 15);
     }
 }
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/Collections/SortedListTests.cs b/tests/Sharpify.Tests/Collections/SortedListTests.cs
index 15ab4f4..8cdb193 100644
--- a/tests/Sharpify.Tests/Collections/SortedListTests.cs
+++ b/tests/Sharpify.Tests/Collections/SortedListTests.cs
@@ -12,7 +12,7 @@ public void SortedList_Add() {
 		list.Add(6);
 
 		// Assert
-		list.GetIndex(6).Should().Be(list.Count - 1);
+		Assert.Equal(list.Count - 1, list.GetIndex(6));
 
 		// Act
 		int count = list.Count;
@@ -20,7 +20,7 @@ public void SortedList_Add() {
 
 		// Assert
 		// Duplicates should be ignored, no change to count
-		list.Count.Should().Be(count);
+		Assert.Equal(count, list.Count);
 	}
 
 	[Fact]
@@ -32,7 +32,7 @@ public void SortedList_AddRange_Span() {
 		list.AddRange(new ReadOnlySpan<int>([6, 7, 8]));
 
 		// Assert
-		list.Span.SequenceEqual([1, 2, 3, 4, 5, 6, 7, 8]).Should().BeTrue();
+		Assert.Equal([1, 2, 3, 4, 5, 6, 7, 8], list.Span);
 	}
 
 	[Fact]
@@ -44,7 +44,7 @@ public void SortedList_AddRange_IEnumerable() {
 		list.AddRange(new List<int>() { 6, 7, 8 });
 
 		// Assert
-		list.Span.SequenceEqual([1, 2, 3, 4, 5, 6, 7, 8]).Should().BeTrue();
+		Assert.Equal([1, 2, 3, 4, 5, 6, 7, 8], list.Span);
 	}
 
 	[Fact]
@@ -56,17 +56,17 @@ public void SortedList_Remove() {
 		list.Remove(3);
 
 		// Assert
-		list.GetIndex(3).Should().BeLessThan(0);
+		Assert.True(list.GetIndex(3) < 0);
 
 		// Act
 		for (int i = 0; i < 5; i++) {
 			list.Add(6);
 		}
-		list.Count.Should().Be(5 - 1 + 5);
+		Assert.Equal(5 - 1 + 5, list.Count);
 		list.Remove(6);
 
 		// Assert
-		list.GetIndex(6).Should().BeLessThan(0);
+		Assert.True(list.GetIndex(6) < 0);
 	}
 
 	[Fact]
@@ -75,7 +75,7 @@ public void SortedList_GetIndex_Existing() {
 		var list = new SortedList<int>([1, 2, 3, 4, 5]);
 
 		// Assert
-		list.GetIndex(4).Should().Be(3);
+		Assert.Equal(3, list.GetIndex(4));
 	}
 
 	[Fact]
@@ -84,7 +84,7 @@ public void SortedList_GetIndex_OrIndexOfInsertion() {
 		var list = new SortedList<int>([1, 2, 3, 5, 6]);
 
 		// Assert
-		(~list.GetIndex(4)).Should().Be(3);
+		Assert.Equal(3, ~list.GetIndex(4));
 	}
 
 	[Fact]
@@ -93,7 +93,7 @@ public void SortedList_GetIndex_OrIndexOfInsertion_Larger() {
 		var list = new SortedList<int>([1, 2, 3, 5, 6]);
 
 		// Assert
-		(~list.GetIndex(7)).Should().BeGreaterThan(list.Count - 1);
+		Assert.True(~list.GetIndex(7) > list.Count - 1);
 	}
 
 	[Fact]
@@ -106,7 +106,7 @@ public void SortedList_GetIndex_OrIndexOfInsertion_LargerSection() {
 		ReadOnlySpan<int> section = list.Span.Slice(~index);
 
 		// Assert
-		section.SequenceEqual(new[] { 5, 6 }).Should().BeTrue();
+		Assert.Equal([5, 6], section);
 	}
 
 	[Fact]
@@ -123,11 +123,11 @@ public void SortedList_GetIndex_OrIndexOfInsertion_LargerSection_Class() {
 
 		// Act + Assert
 		var section = list.Span.Slice(~list.GetIndex(new Person("f", 4)));
-		section.SequenceEqual([ new Person("d", 5), new Person("e",6) ]).Should().BeTrue();
+		Assert.Equal([new Person("d", 5), new Person("e", 6)], section);
 
 		// Act + Assert
 		section = list.Span.Slice(list.GetIndex(new Person("f", 3)) + 1);
-		section.SequenceEqual([ new Person("d", 5), new Person("e",6) ]).Should().BeTrue();
+		Assert.Equal([new Person("d", 5), new Person("e", 6)], section);
 	}
 
 	private record Person(string Name, int Age) : IComparable<Person> {
diff --git a/tests/Sharpify.Tests/Collections/StringBuffersTests.cs b/tests/Sharpify.Tests/Collections/StringBuffersTests.cs
index 9e14cbb..4dd222c 100644
--- a/tests/Sharpify.Tests/Collections/StringBuffersTests.cs
+++ b/tests/Sharpify.Tests/Collections/StringBuffersTests.cs
@@ -12,7 +12,7 @@ public void StringBuffer_NoCapacity_Throws() {
         };
 
         // Act & Assert
-        act.Should().Throw<ArgumentOutOfRangeException>();
+        Assert.Throws<ArgumentOutOfRangeException>(act);
     }
 
     [Fact]
@@ -27,7 +27,7 @@ public void StringBuffer_Append_ToFullCapacity() {
         };
 
         // Assert
-        act.Should().NotThrow<ArgumentOutOfRangeException>();
+        act();
     }
 
     [Fact]
@@ -42,7 +42,7 @@ public void StringBuffer_Append_BeyondCapacity() {
         };
 
         // Assert
-        act.Should().Throw<ArgumentOutOfRangeException>();
+        Assert.Throws<ArgumentOutOfRangeException>(act);
     }
 
     [Fact]
@@ -69,9 +69,9 @@ public void StringBuffer_Append_BeyondToCapacityAndBeyond() {
         };
 
         // Assert
-        act1.Should().Throw<ArgumentOutOfRangeException>();
-        act2.Should().Throw<ArgumentOutOfRangeException>();
-        act3.Should().Throw<ArgumentOutOfRangeException>();
+        Assert.Throws<ArgumentOutOfRangeException>(act1);
+        Assert.Throws<ArgumentOutOfRangeException>(act2);
+        Assert.Throws<ArgumentOutOfRangeException>(act3);
     }
 
     [Fact]
@@ -86,7 +86,7 @@ public void StringBuffer_AppendLine_OnElement() {
         var expected = string.Create(null, stackalloc char[20], $"Hello{Environment.NewLine}World");
 
         // Assert
-        buffer.Allocate(true).Should().Be(expected);
+        Assert.Equal(expected, buffer.Allocate(true));
     }
 
     [Fact]
@@ -102,7 +102,7 @@ public void StringBuffer_AppendLine_NoParams() {
         var expected = string.Create(null, stackalloc char[20], $"Hello{Environment.NewLine}World");
 
         // Assert
-        buffer.Allocate(true).Should().Be(expected);
+        Assert.Equal(expected, buffer.Allocate(true));
     }
 
     [Fact]
@@ -118,7 +118,7 @@ public void StringBuffer_AppendLine_NoParams_Builder() {
         var expected = string.Create(null, stackalloc char[20], $"Hello{Environment.NewLine}World");
 
         // Assert
-        buffer.Allocate(true).Should().Be(expected);
+        Assert.Equal(expected, buffer.Allocate(true));
     }
 
     [Fact]
@@ -133,7 +133,7 @@ public void StringBuffer_NoTrimming_ReturnFullString() {
         buffer.Append('d');
 
         // Assert
-        buffer.Allocate(false).Should().Be("abcd\0");
+        Assert.Equal("abcd\0", buffer.Allocate(false));
     }
 
     [Fact]
@@ -148,7 +148,7 @@ public void StringBuffer_WithTrimming_ReturnTrimmedString() {
         buffer.Append('d');
 
         // Assert
-        buffer.Allocate(true).Should().Be("abcd");
+        Assert.Equal("abcd", buffer.Allocate(true));
     }
 
     [Fact]
@@ -164,7 +164,7 @@ public void StringBuffer_WithWhiteSpaceTrimming_ReturnTrimmedString() {
         buffer.Append(' ');
 
         // Assert
-        buffer.Allocate(true, true).Should().Be("abcd");
+        Assert.Equal("abcd", buffer.Allocate(true, true));
     }
 
     [Fact]
@@ -178,6 +178,6 @@ public void StringBuffer_Reset() {
         buffer.Append("David");
 
         // Assert
-        buffer.WrittenSpan.SequenceEqual("David").Should().BeTrue();
+        Assert.Equal("David", buffer.WrittenSpan);
     }
 }
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/EitherTests.cs b/tests/Sharpify.Tests/EitherTests.cs
index 268c8c4..9ba6b2c 100644
--- a/tests/Sharpify.Tests/EitherTests.cs
+++ b/tests/Sharpify.Tests/EitherTests.cs
@@ -7,8 +7,8 @@ public void ImplicitOperatorFromT0_CreatesEitherWithT0Value() {
         Either<int, string> either = 42;
 
         // Assert
-        either.IsT0.Should().BeTrue();
-        either.AsT0.Should().Be(42);
+        Assert.True(either.IsT0);
+        Assert.Equal(42, either.AsT0);
     }
 
     [Fact]
@@ -17,8 +17,8 @@ public void ImplicitOperatorFromT1_CreatesEitherWithT1Value() {
         Either<int, string> either = "Hello";
 
         // Assert
-        either.IsT1.Should().BeTrue();
-        either.AsT1.Should().Be("Hello");
+        Assert.True(either.IsT1);
+        Assert.Equal("Hello", either.AsT1);
     }
 
     [Fact]
@@ -32,8 +32,8 @@ public void Switch_WhenT0Value_IsUsed_CallsT0Handler() {
         either.Switch(t0 => t0HandlerCalled = true, t1 => t1HandlerCalled = false);
 
         // Assert
-        t0HandlerCalled.Should().BeTrue();
-        t1HandlerCalled.Should().BeFalse();
+        Assert.True(t0HandlerCalled);
+        Assert.False(t1HandlerCalled);
     }
 
     [Fact]
@@ -47,8 +47,8 @@ public void Switch_WhenT1Value_IsUsed_CallsT1Handler() {
         either.Switch(t0 => t0HandlerCalled = true, t1 => t1HandlerCalled = true);
 
         // Assert
-        t0HandlerCalled.Should().BeFalse();
-        t1HandlerCalled.Should().BeTrue();
+        Assert.False(t0HandlerCalled);
+        Assert.True(t1HandlerCalled);
     }
 
     [Fact]
@@ -60,7 +60,7 @@ public void Match_WhenT0Value_IsUsed_ReturnsResultFromT0Handler() {
         var result = either.Match(t0 => t0 * 2, t1 => t1.Length);
 
         // Assert
-        result.Should().Be(84);
+        Assert.Equal(84, result);
     }
 
     [Fact]
@@ -72,6 +72,6 @@ public void Match_WhenT1Value_IsUsed_ReturnsResultFromT1Handler() {
         var result = either.Match(t0 => t0 * 2, t1 => t1.Length);
 
         // Assert
-        result.Should().Be(5);
+        Assert.Equal(5, result);
     }
 }
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/ParallelExtensionsTests.cs b/tests/Sharpify.Tests/ParallelExtensionsTests.cs
index 7d1066c..43d87fc 100644
--- a/tests/Sharpify.Tests/ParallelExtensionsTests.cs
+++ b/tests/Sharpify.Tests/ParallelExtensionsTests.cs
@@ -15,7 +15,7 @@ public async Task ForAll_WithAsyncAction() {
         var expected = dict.ToDictionary(x => x.Key, x => x.Value * 2);
 
         // Assert
-        results.Should().Equal(expected);
+        Assert.Equal(expected, results);
     }
 
     [Fact]
@@ -34,7 +34,7 @@ await dict.ForAll((x, token) => {
         var expected = dict.ToDictionary(x => x.Key, x => x.Value * 2);
 
         // Assert
-        results.Should().Equal(expected);
+        Assert.Equal(expected, results);
     }
 
     [Fact]
@@ -49,7 +49,7 @@ public async Task ForAllAsync_WithAsyncAction() {
         var expected = dict.ToDictionary(x => x.Key, x => x.Value * 2);
 
         // Assert
-        results.Should().Equal(expected);
+        Assert.Equal(expected, results);
     }
 
     [Fact]
@@ -68,7 +68,7 @@ await dict.ForAllAsync(async (x, token) => {
         var expected = dict.ToDictionary(x => x.Key, x => x.Value * 2);
 
         // Assert
-        results.Should().Equal(expected);
+        Assert.Equal(expected, results);
     }
 
     [Fact]
@@ -87,7 +87,7 @@ await dict.ForAllAsync(async (x, token) => {
         var expected = dict.ToDictionary(x => x.Key, x => x.Value * 2);
 
         // Assert
-        results.Should().Equal(expected);
+        Assert.Equal(expected, results);
     }
 }
 
diff --git a/tests/Sharpify.Tests/ResultTests.cs b/tests/Sharpify.Tests/ResultTests.cs
index e7cb0b5..c8cbe8a 100644
--- a/tests/Sharpify.Tests/ResultTests.cs
+++ b/tests/Sharpify.Tests/ResultTests.cs
@@ -9,7 +9,7 @@ public void Result_DefaultConstructor_ThrowsException() {
         };
 
         // Assert
-        act.Should().Throw<InvalidOperationException>();
+        Assert.Throws<InvalidOperationException>(act);
     }
 
     [Fact]
@@ -20,7 +20,7 @@ public void ResultT_DefaultConstructor_ThrowsException() {
         };
 
         // Assert
-        act.Should().Throw<InvalidOperationException>();
+        Assert.Throws<InvalidOperationException>(act);
     }
 
     [Fact]
@@ -29,8 +29,8 @@ public void Ok_ResultWithoutMessage_ReturnsResultWithIsOkTrueAndNoMessage() {
         var result = Result.Ok();
 
         // Assert
-        result.IsOk.Should().BeTrue();
-        result.Message.Should().BeEmpty();
+        Assert.True(result.IsOk);
+        Assert.Empty(result.Message);
     }
 
     [Fact]
@@ -39,8 +39,8 @@ public void Ok_ResultWithMessage_ReturnsResultWithIsOkTrueAndMessage() {
         var result = Result.Ok("Success");
 
         // Assert
-        result.IsOk.Should().BeTrue();
-        result.Message.Should().Be("Success");
+        Assert.True(result.IsOk);
+        Assert.Equal("Success", result.Message);
     }
 
     [Fact]
@@ -49,8 +49,8 @@ public void Fail_ResultWithMessage_ReturnsResultWithIsOkFalseAndMessage() {
         var result = Result.Fail("Failure");
 
         // Assert
-        result.IsOk.Should().BeFalse();
-        result.Message.Should().Be("Failure");
+        Assert.False(result.IsOk);
+        Assert.Equal("Failure", result.Message);
     }
 
     [Fact]
@@ -59,8 +59,8 @@ public void Ok_ResultWithValue_ReturnsResultWithIsOkTrueAndValue() {
         var result = Result.Ok(42);
 
         // Assert
-        result.IsOk.Should().BeTrue();
-        result.Value.Should().Be(42);
+        Assert.True(result.IsOk);
+        Assert.Equal(42, result.Value);
     }
 
     [Fact]
@@ -69,9 +69,9 @@ public void Ok_ResultWithValueAndMessage_ReturnsResultWithIsOkTrueAndValueAndMes
         var result = Result.Ok("Success", 42);
 
         // Assert
-        result.IsOk.Should().BeTrue();
-        result.Value.Should().Be(42);
-        result.Message.Should().Be("Success");
+        Assert.True(result.IsOk);
+        Assert.Equal("Success", result.Message);
+        Assert.Equal(42, result.Value);
     }
 
     [Fact]
@@ -83,8 +83,8 @@ public void WithValue_ResultWithValue_ReturnsResultWithValueAndIsOkAndMessage()
         var valueResult = result.WithValue(42);
 
         // Assert
-        valueResult.IsOk.Should().BeTrue();
-        valueResult.Value.Should().Be(42);
-        valueResult.Message.Should().Be("Success");
+        Assert.True(valueResult.IsOk);
+        Assert.Equal("Success", valueResult.Message);
+        Assert.Equal(42, valueResult.Value);
     }
 }
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/Routines/AsyncRoutineTests.cs b/tests/Sharpify.Tests/Routines/AsyncRoutineTests.cs
index b377b72..4ea6624 100644
--- a/tests/Sharpify.Tests/Routines/AsyncRoutineTests.cs
+++ b/tests/Sharpify.Tests/Routines/AsyncRoutineTests.cs
@@ -28,6 +28,6 @@ public async Task AsyncRoutine_GivenIncreaseValueFunction_IncreasesValue(int exp
         await tcs.Task;
 
         // Assert
-        count.Should().BeGreaterThanOrEqualTo(expected);
+        Assert.True(count >= expected);
     }
 }
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/Routines/RoutineTests.cs b/tests/Sharpify.Tests/Routines/RoutineTests.cs
index 8f80b65..9aa19e5 100644
--- a/tests/Sharpify.Tests/Routines/RoutineTests.cs
+++ b/tests/Sharpify.Tests/Routines/RoutineTests.cs
@@ -24,6 +24,6 @@ public async Task Routine_GivenIncreaseValueFunction_IncreasesValue(int expected
         await tcs.Task;
 
         // Assert
-        count.Should().BeGreaterThanOrEqualTo(expected);
+        Assert.True(count >= expected);
     }
 }
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/SerializableObjectTests.cs b/tests/Sharpify.Tests/SerializableObjectTests.cs
index 3148d49..46b254d 100644
--- a/tests/Sharpify.Tests/SerializableObjectTests.cs
+++ b/tests/Sharpify.Tests/SerializableObjectTests.cs
@@ -1,4 +1,3 @@
-
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
@@ -14,7 +13,7 @@ public async Task Constructor_Throws_When_Filename_Is_Invalid() {
         var action = () => new MonitoredSerializableObject<Configuration>(dir, JsonContext.Default.Configuration); // no filename
 
         // Act & Assert
-        action.Should().Throw<ArgumentException>();
+        Assert.Throws<ArgumentException>(action);
 
         // Cleanup
         await file.DeleteAsync();
@@ -27,10 +26,10 @@ public async Task Constructor_Creates_File_When_File_Does_Not_Exist() {
         var action = () => new MonitoredSerializableObject<Configuration>(file.Path, JsonContext.Default.Configuration);
 
         // Act
-        action.Should().NotThrow();
+        action();
 
         // Assert
-        File.Exists(file).Should().BeTrue();
+        Assert.True(File.Exists(file));
         await file.DeleteAsync();
     }
 
@@ -42,13 +41,13 @@ public async Task Constructor_Deserializes_File_When_File_Exists() {
         var action = () => new MonitoredSerializableObject<Configuration>(file.Path, config, JsonContext.Default.Configuration);
 
         // Act
-        action.Should().NotThrow();
+        action();
         // Assert
-        File.Exists(file).Should().BeTrue();
+        Assert.True(File.Exists(file));
         // Act
         using var obj = new MonitoredSerializableObject<Configuration>(file.Path, JsonContext.Default.Configuration);
         // Assert
-        obj.Value.Should().BeEquivalentTo(config);
+        Assert.Equal(config, obj.Value);
 
         // Cleanup
         await file.DeleteAsync();
@@ -65,9 +64,9 @@ public async Task Modify_SerializesProperly() {
         // Act
         obj.Modify(c => c with { Name = newName });
         // Assert
-        obj.Value.Name.Should().Be(newName);
+        Assert.Equal(newName, obj.Value.Name);
         using var obj2 = new MonitoredSerializableObject<Configuration>(file.Path, JsonContext.Default.Configuration);
-        obj2.Value.Name.Should().BeEquivalentTo(newName);
+        Assert.Equal(newName, obj2.Value.Name);
 
         // Cleanup
         await file.DeleteAsync();
@@ -90,8 +89,8 @@ public async Task Modify_FiresEventOnce_WithProperArgs() {
         // Act
         obj.Modify(c => c with { Name = newName });
         // Assert
-        count.Should().Be(1);
-        lastValue.Name.Should().Be(newName);
+        Assert.Equal(1, count);
+        Assert.Equal(newName, lastValue.Name);
 
         // Cleanup
         await file.DeleteAsync();
@@ -108,7 +107,7 @@ public async Task OnFileChanged_DoesntChangeWhenFileIsEmpty() {
         await File.WriteAllTextAsync(file, "");
 
         // Assert
-        obj.Value.Name.Should().Be("John Doe");
+        Assert.Equal("John Doe", obj.Value.Name);
 
         // Cleanup
         await file.DeleteAsync();
@@ -128,7 +127,7 @@ public async Task OnFileChanged_DoesntChangeWhenFileIsInvalid() {
         // Act
         await File.WriteAllTextAsync(file, "invalid json");
         // Assert
-        count.Should().Be(0);
+        Assert.Equal(0, count);
 
         // Cleanup
         await file.DeleteAsync();
@@ -141,7 +140,7 @@ public async Task OnFileChanged_ChangesWhenFileIsValid() {
         var config = new Configuration { Name = "John Doe", Age = 42 };
         using var obj = new MonitoredSerializableObject<Configuration>(file, config, JsonContext.Default.Configuration);
         // Assert
-        obj.OnChanged += (sender, e) => e.Value.Name.Should().Be("Jane");
+        obj.OnChanged += (sender, e) => Assert.Equal("Jane", e.Value.Name);
 
         // Act
         await File.WriteAllTextAsync(file, JsonSerializer.Serialize(config with { Name = "Jane" }, JsonContext.Default.Configuration));
diff --git a/tests/Sharpify.Tests/Sharpify.Tests.csproj b/tests/Sharpify.Tests/Sharpify.Tests.csproj
index 7e7966b..498fb4b 100644
--- a/tests/Sharpify.Tests/Sharpify.Tests.csproj
+++ b/tests/Sharpify.Tests/Sharpify.Tests.csproj
@@ -11,14 +11,13 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentAssertions" Version="6.12.2" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
-    <PackageReference Include="xunit" Version="2.9.2" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.1">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="6.0.2">
+    <PackageReference Include="coverlet.collector" Version="6.0.3">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
diff --git a/tests/Sharpify.Tests/StringExtensionsTests.cs b/tests/Sharpify.Tests/StringExtensionsTests.cs
index 5746a26..545df71 100644
--- a/tests/Sharpify.Tests/StringExtensionsTests.cs
+++ b/tests/Sharpify.Tests/StringExtensionsTests.cs
@@ -11,7 +11,7 @@ public void IsNullOrEmpty_GivenNullString_ReturnsTrue() {
         var result = value.IsNullOrEmpty();
 
         // Assert
-        result.Should().BeTrue();
+        Assert.True(result);
     }
 
     [Fact]
@@ -23,7 +23,7 @@ public void IsNullOrEmpty_GivenEmptyString_ReturnsTrue() {
         var result = value.IsNullOrEmpty();
 
         // Assert
-        result.Should().BeTrue();
+        Assert.True(result);
     }
 
     [Fact]
@@ -35,7 +35,7 @@ public void IsNullOrWhiteSpace_GivenNullString_ReturnsTrue() {
         var result = value.IsNullOrWhiteSpace();
 
         // Assert
-        result.Should().BeTrue();
+        Assert.True(result);
     }
 
     [Fact]
@@ -47,7 +47,7 @@ public void IsNullOrWhiteSpace_GivenEmptyString_ReturnsTrue() {
         var result = value.IsNullOrWhiteSpace();
 
         // Assert
-        result.Should().BeTrue();
+        Assert.True(result);
     }
 
     [Fact]
@@ -59,7 +59,7 @@ public void IsNullOrWhiteSpace_GivenWhiteSpaceString_ReturnsTrue() {
         var result = value.IsNullOrWhiteSpace();
 
         // Assert
-        result.Should().BeTrue();
+        Assert.True(result);
     }
 
     [Theory]
@@ -70,8 +70,8 @@ public void IsNullOrWhiteSpace_GivenWhiteSpaceString_ReturnsTrue() {
     public void TryConvertToInt32_ValidString_ReturnsTrue(string input, int expected) {
         bool result = input.AsSpan().TryConvertToInt32(out var output);
 
-        result.Should().BeTrue();
-        output.Should().Be(expected);
+        Assert.True(result);
+        Assert.Equal(expected, output);
     }
 
     [Theory]
@@ -83,8 +83,8 @@ public void TryConvertToInt32_ValidString_ReturnsTrue(string input, int expected
     public void TryConvertToInt32_InvalidString_ReturnsFalse(string input) {
         bool result = input.AsSpan().TryConvertToInt32(out var output);
 
-        result.Should().BeFalse();
-        output.Should().Be(0); // Ensure that the value is not changed in case of failure
+        Assert.False(result);
+        Assert.Equal(0, output); // Ensure that the value is not changed in case of failure
     }
 
     // Tests for Concat
@@ -102,7 +102,7 @@ public void Concat_WithVariousInputs_ReturnsCorrectResult(
         string result = value.Concat(suffix);
 
         // Assert
-        result.Should().Be(expectedResult);
+        Assert.Equal(expectedResult, result);
     }
 
     // Tests for ToTitle
@@ -115,7 +115,7 @@ public void ToTitle_WithVariousInputs_ReturnsTitleCase(
         string result = input.ToTitle();
 
         // Assert
-        result.Should().Be(expectedResult);
+        Assert.Equal(expectedResult, result);
     }
 
     // Tests for IsBinary
@@ -132,7 +132,7 @@ public void IsBinary_WithVariousInputs_ReturnsCorrectResult(
         bool result = input.IsBinary();
 
         // Assert
-        result.Should().Be(expectedResult);
+        Assert.Equal(expectedResult, result);
     }
 }
 #pragma warning restore
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/ThreadSafeTests.cs b/tests/Sharpify.Tests/ThreadSafeTests.cs
index e2f3aec..469f754 100644
--- a/tests/Sharpify.Tests/ThreadSafeTests.cs
+++ b/tests/Sharpify.Tests/ThreadSafeTests.cs
@@ -5,7 +5,7 @@ public class ThreadSafeTests {
     public void ThreadSafe_EmptyConstructor() {
         ThreadSafe<int> wrapper = new();
 
-        wrapper.Value.Should().Be(0);
+        Assert.Equal(0, wrapper.Value);
     }
 
     [Fact]
@@ -14,7 +14,7 @@ public void ThreadSafe_ValueConstructor() {
 
         int result = wrapper.Value;
 
-        result.Should().Be(42);
+        Assert.Equal(42, result);
     }
 
     [Fact]
@@ -24,7 +24,7 @@ public void ThreadSafe_UpdateValue() {
 
         int result = wrapper.Modify(_ => newValue);
 
-        result.Should().Be(newValue);
+        Assert.Equal(newValue, result);
     }
 
     [Theory]
@@ -36,7 +36,7 @@ public void ThreadSafe_ModifyValue(int original, int addition, int expected) {
 
         int result = wrapper.Modify(value => value + addition);
 
-        result.Should().Be(expected);
+        Assert.Equal(expected, result);
     }
 
     [Theory]
@@ -49,7 +49,7 @@ public async Task ThreadSafe_MultiThreadedAccess(int amount, int expected) {
         var tasks = Enumerable.Range(0, amount).AsParallel().Select(i => Task.Run(() => wrapper.Modify(value => value + 1)));
         await Task.WhenAll(tasks);
 
-        wrapper.Value.Should().Be(expected);
+        Assert.Equal(expected, wrapper.Value);
     }
 
     [Fact]
@@ -61,7 +61,7 @@ public void ThreadSafe_GetHashCode() {
         int actual = wrapper.GetHashCode();
         int expected = val.GetHashCode();
 
-        actual.Should().Be(expected);
+        Assert.Equal(expected, actual);
     }
 
     [Theory]
@@ -72,7 +72,7 @@ public void ThreadSafe_GetHashCode() {
     public void ThreadSafe_Equals(int actual, int expected) {
         ThreadSafe<int> wrapper = new(actual);
 
-        wrapper.Equals(expected).Should().BeTrue();
+        Assert.True(wrapper.Equals(expected));
     }
 
     [Fact]
@@ -81,7 +81,7 @@ public void ThreadSafe_Equals_Null() {
 
         ThreadSafe<int> wrapper = new(val);
 
-        wrapper.Equals(null).Should().BeFalse();
+        Assert.False(wrapper.Equals(null));
     }
 
     [Fact]
@@ -90,7 +90,7 @@ public void ThreadSafe_Equals_ThreadSafe() {
 
         ThreadSafe<int> wrapper = new(val);
 
-        wrapper.Equals(new ThreadSafe<int>(val)).Should().BeTrue();
+        Assert.True(wrapper.Equals(new ThreadSafe<int>(val)));
     }
 
     [Fact]
@@ -100,7 +100,7 @@ public void ThreadSafe_Equals_Object() {
         ThreadSafe<int> wrapper = new(val);
         var other = (object)new ThreadSafe<int>(val);
 
-        wrapper.Equals(other).Should().BeTrue();
+        Assert.True(wrapper.Equals(other));
     }
 
     [Fact]
@@ -110,6 +110,6 @@ public void ThreadSafe_Equals_NullObject() {
         ThreadSafe<int> wrapper = new(val);
         object? other = null;
 
-        wrapper.Equals(other).Should().BeFalse();
+        Assert.False(wrapper.Equals(other));
     }
 }
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/UnmanagedExtensionsTests.cs b/tests/Sharpify.Tests/UnmanagedExtensionsTests.cs
index 7e18d86..737615f 100644
--- a/tests/Sharpify.Tests/UnmanagedExtensionsTests.cs
+++ b/tests/Sharpify.Tests/UnmanagedExtensionsTests.cs
@@ -19,7 +19,7 @@ public void TryParseAsEnum_WithVariousInputs_ReturnsCorrectResult(
         bool result = value.TryParseAsEnum(out ExampleEnum parsedEnum);
 
         // Assert
-        result.Should().Be(expectedResult);
-        parsedEnum.Should().Be(expectedEnum);
+        Assert.Equal(expectedResult, result);
+        Assert.Equal(expectedEnum, parsedEnum);
     }
 }
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/UnsafeSpanIteratorTests.cs b/tests/Sharpify.Tests/UnsafeSpanIteratorTests.cs
index 132201f..9661934 100644
--- a/tests/Sharpify.Tests/UnsafeSpanIteratorTests.cs
+++ b/tests/Sharpify.Tests/UnsafeSpanIteratorTests.cs
@@ -12,7 +12,7 @@ public void UnsafeSpanIterator_UseLinq() {
         var sum = iterator.Select(x => x + 1).Sum(); // [0-99] -> [1-100]
 
         // Assert
-        sum.Should().Be(5050);
+        Assert.Equal(5050, sum);
     }
 
     [Fact]
@@ -31,7 +31,7 @@ async Task Increment(int item) {
         await Task.WhenAll(tasks);
 
         // Assert
-        sum.Should().Be(5050);
+        Assert.Equal(5050, sum);
     }
 
     [Fact]
@@ -44,7 +44,7 @@ public void UnsafeSpanIterator_Slice() {
         var slice = iterator.Slice(3, 2);
 
         // Assert
-        slice.SequenceEqual([4, 5]).Should().BeTrue();
+        Assert.Equal(slice, [4, 5]);
     }
 
     [Fact]
@@ -57,7 +57,7 @@ public void UnsafeSpanIterator_ToEnumerable() {
         var count = iterator.ToEnumerable().Count();
 
         // Assert
-        count.Should().Be(items.Length);
+        Assert.Equal(items.Length, count);
     }
 
     [Fact]
@@ -70,7 +70,7 @@ public void UnsafeSpanIterator_SliceBeyondBounds_Throws() {
         var act = () => { var slice = iterator.Slice(4, 4); };
 
         // Assert
-        act.Should().Throw<ArgumentOutOfRangeException>();
+        Assert.Throws<ArgumentOutOfRangeException>(act);
     }
 
     [Fact]
@@ -82,7 +82,7 @@ public void UnsafeSpanIterator_GetByIndex() {
         var iterator = new UnsafeSpanIterator<int>(items);
 
         // Assert
-        iterator[3].Should().Be(4);
+        Assert.Equal(4, iterator[3]);
     }
 
     [Fact]
@@ -95,6 +95,6 @@ public void UnsafeSpanIterator_GetByIndexBeyondBounds_Throws() {
         var act = () => { var item = iterator[9]; };
 
         // Assert
-        act.Should().Throw<ArgumentOutOfRangeException>();
+        Assert.Throws<ArgumentOutOfRangeException>(act);
     }
 }
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/Usings.cs b/tests/Sharpify.Tests/Usings.cs
index dbf65b2..7299b8b 100644
--- a/tests/Sharpify.Tests/Usings.cs
+++ b/tests/Sharpify.Tests/Usings.cs
@@ -1,6 +1,5 @@
 global using System.Collections.Generic;
 global using System.Runtime.CompilerServices;
 global using System.Runtime.InteropServices;
-global using FluentAssertions;
 global using Sharpify;
 global using Xunit;
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/UtilsDateAndTimeTests.cs b/tests/Sharpify.Tests/UtilsDateAndTimeTests.cs
index 8c33cb1..3edfc01 100644
--- a/tests/Sharpify.Tests/UtilsDateAndTimeTests.cs
+++ b/tests/Sharpify.Tests/UtilsDateAndTimeTests.cs
@@ -21,7 +21,7 @@ public void FormatTimeSpan_ReturnsFormattedSpan(double seconds, string expected)
         ReadOnlySpan<char> result = Utils.DateAndTime.FormatTimeSpan(elapsed, owner.Memory.Span);
 
         // Assert
-        result.SequenceEqual(expected).Should().BeTrue();
+        Assert.Equal(expected, result);
     }
 
     [Theory]
@@ -41,7 +41,7 @@ public void FormatTimeSpan_ReturnsFormattedString(double seconds, string expecte
         string result = Utils.DateAndTime.FormatTimeSpan(elapsed);
 
         // Assert
-        result.Equals(expected).Should().BeTrue();
+        Assert.Equal(expected, result);
     }
 
     [Fact]
@@ -54,7 +54,7 @@ public void ToTimeStamp_ReturnsFormattedSpan() {
         ReadOnlySpan<char> result = Utils.DateAndTime.FormatTimeStamp(dateTime, owner.Memory.Span);
 
         // Assert
-        result.SequenceEqual("1355-6-Apr-22").Should().BeTrue();
+        Assert.Equal("1355-6-Apr-22", result);
     }
 
     [Fact]
@@ -66,7 +66,7 @@ public void ToTimeStamp_ReturnsFormattedString() {
         string result = Utils.DateAndTime.FormatTimeStamp(dateTime);
 
         // Assert
-        result.Equals("1355-6-Apr-22").Should().BeTrue();
+        Assert.Equal("1355-6-Apr-22", result);
     }
 
     [Fact]
@@ -78,7 +78,7 @@ public async Task GetCurrentTimeAsync_ReturnsCurrentTime() {
         var result = await Utils.DateAndTime.GetCurrentTimeAsync();
 
         // Assert
-        result.Should().BeCloseTo(expected, TimeSpan.FromSeconds(1));
+        Assert.Equal(expected, result, TimeSpan.FromSeconds(1));
     }
 
     [Fact]
@@ -91,6 +91,6 @@ public async Task GetCurrentTimeInBinaryAsync_ReturnsCurrentTimeInBinary() {
         var fromResult = DateTime.FromBinary(result);
 
         // Assert
-        fromResult.Should().BeCloseTo(expected, TimeSpan.FromSeconds(1));
+        Assert.Equal(expected, fromResult, TimeSpan.FromSeconds(1));
     }
 }
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/UtilsMathematicsTests.cs b/tests/Sharpify.Tests/UtilsMathematicsTests.cs
index e51626d..5fce068 100644
--- a/tests/Sharpify.Tests/UtilsMathematicsTests.cs
+++ b/tests/Sharpify.Tests/UtilsMathematicsTests.cs
@@ -15,7 +15,7 @@ public void RollingAverage_WithVariousInputs_ReturnsCorrectResult(
         result = Math.Round(result, 3);
 
         // Assert
-        result.Should().Be(expectedResult);
+        Assert.Equal(expectedResult, result);
     }
 
     [Theory]
@@ -27,7 +27,7 @@ public void Factorial_ValidInput_ValidResult(double n, double expected) {
         var result = Utils.Mathematics.Factorial(n);
 
         // Assert
-        result.Should().Be(expected);
+        Assert.Equal(expected, result);
     }
 
     [Theory]
@@ -41,6 +41,6 @@ public void FibonacciApproximation_ValidInput_ValidResult(int n, double expected
 
         // Assert
         const double margin = 0.01;
-        result.Should().BeApproximately(expected, margin);
+        Assert.Equal(expected, result, margin);
     }
 }
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/UtilsStringsTests.cs b/tests/Sharpify.Tests/UtilsStringsTests.cs
index 8661acd..b5052f8 100644
--- a/tests/Sharpify.Tests/UtilsStringsTests.cs
+++ b/tests/Sharpify.Tests/UtilsStringsTests.cs
@@ -16,7 +16,7 @@ public void FormatBytes_DoubleWithVariousInputs_ReturnsCorrectResult(
         string result = Utils.Strings.FormatBytes(bytes);
 
         // Assert
-        result.Should().Be(expectedResult);
+        Assert.Equal(expectedResult, result);
     }
 
     [Theory]
@@ -33,7 +33,7 @@ public void FormatBytes_LongWithVariousInputs_ReturnsCorrectResult(
         string result = Utils.Strings.FormatBytes(bytes);
 
         // Assert
-        result.Should().Be(expectedResult);
+        Assert.Equal(expectedResult, result);
     }
 
     [Theory]
@@ -46,7 +46,7 @@ public void FormatBytes_LongWithNonRoundedInputs_ReturnsCorrectResult(
         string result = Utils.Strings.FormatBytes(bytes);
 
         // Assert
-        result.Should().Be(expectedResult);
+        Assert.Equal(expectedResult, result);
     }
 
     [Theory]
@@ -59,7 +59,7 @@ public void FormatBytes_DoubleWithNonRoundedInputs_ReturnsCorrectResult(
         string result = Utils.Strings.FormatBytes(bytes);
 
         // Assert
-        result.Should().Be(expectedResult);
+        Assert.Equal(expectedResult, result);
     }
 
     [Fact]
@@ -68,7 +68,7 @@ public void FormatBytes_Double_HasEnoughCapacity() {
         Action act = () => _ = Utils.Strings.FormatBytes(double.MaxValue);
 
         // Assert
-        act.Should().NotThrow<ArgumentOutOfRangeException>();
+        act();
     }
 
     [Fact]
@@ -77,6 +77,6 @@ public void FormatBytes_Long_HasEnoughCapacity() {
         Action act = () => _ = Utils.Strings.FormatBytes(long.MaxValue);
 
         // Assert
-        act.Should().NotThrow<ArgumentOutOfRangeException>();
+        act();
     }
 }
\ No newline at end of file
diff --git a/tests/Sharpify.Tests/UtilsUnsafeTests.cs b/tests/Sharpify.Tests/UtilsUnsafeTests.cs
index 7a1ca5b..d0218bb 100644
--- a/tests/Sharpify.Tests/UtilsUnsafeTests.cs
+++ b/tests/Sharpify.Tests/UtilsUnsafeTests.cs
@@ -11,8 +11,8 @@ public void CreateIntegerPredicate_ForCharIsDigit_Valid() {
         var a = predicate('a');
 
         // Assert
-        one.Should().Be(1);
-        a.Should().Be(0);
+        Assert.Equal(1, one);
+        Assert.Equal(0, a);
     }
 
     [Fact]
@@ -24,8 +24,8 @@ public void TryUnbox_ForValidInput_ValidResult() {
         var result = Utils.Unsafe.TryUnbox<int>(obj, out var value);
 
         // Assert
-        result.Should().BeTrue();
-        value.Should().Be(5);
+        Assert.True(result);
+        Assert.Equal(5, value);
     }
 
     [Fact]
@@ -39,6 +39,6 @@ public void AsMutableSpan_ForValidInput_ValidResult() {
         mutableSpan[2] = '1';
 
         // Assert
-        str.Should().Be("ab1");
+        Assert.Equal("ab1", str);
     }
 }
\ No newline at end of file