Removed FluentAssertions from Sharpify.CLI

Author: dusrdev

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,24 +29,24 @@ 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]
 	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));
 	}
 }