diff --git a/tests/Wolfgang.TryPattern.Tests/ResultOfTTests.cs b/tests/Wolfgang.TryPattern.Tests/ResultOfTTests.cs
index fc0a7b8..b8ab2e3 100644
--- a/tests/Wolfgang.TryPattern.Tests/ResultOfTTests.cs
+++ b/tests/Wolfgang.TryPattern.Tests/ResultOfTTests.cs
@@ -1,6 +1,3 @@
-
-// ReSharper disable AccessToStaticMemberViaDerivedType
-
 namespace Wolfgang.TryPattern.Tests;
 
 public class ResultOfTTests
@@ -174,188 +171,8 @@ public void Success_Nullable_string_sets_properties_correctly(string? value)
     }
 
 
-    
-    [Fact]
-    public void AllSucceeded_when_passed_null_throws_ArgumentNullException()
-    {
-        var ex = Assert.Throws<ArgumentNullException>(() => Result<int>.AllSucceeded(null!));
-        Assert.Equal("results", ex.ParamName);
-    }
-
-
-
-    [Fact]
-    public void AllSucceeded_when_passed_nothing_returns_true()
-    {
-        Assert.True(Result<int>.AllSucceeded());
-    }
-
-
-
-    [Fact]
-    public void AllSucceeded_when_passed_empty_list_returns_true()
-    {
-        Assert.True(Result<int>.AllSucceeded(Array.Empty<Result>()));
-    }
-
-
-
-    [Fact]
-    public void AllSucceeded_when_all_results_succeeded_returns_true()
-    {
-        var result1 = Result<int>.Success();
-        var result2 = Result<int>.Success();
-        var result3 = Result<int>.Success();
-
-        Assert.True(Result<int>.AllSucceeded(result1, result2, result3));
-    }
-
-
-
-    [Fact]
-    public void AllSucceeded_when_at_least_one_result_failed_returns_false()
-    {
-        var result1 = Result<int>.Success();
-        var result2 = Result<int>.Failure("Test");
-        var result3 = Result<int>.Success();
-
-        Assert.False(Result<int>.AllSucceeded(result1, result2, result3));
-
-    }
-
-
-
-    [Fact]
-    public void AnyFailed_when_passed_null_throws_ArgumentNullException()
-    {
-        var ex = Assert.Throws<ArgumentNullException>(() => Result<int>.AnyFailed(null!));
-        Assert.Equal("results", ex.ParamName);
-    }
-
-
-
-    [Fact]
-    public void AnyFailed_when_nothing_returns_false()
-    {
-        Assert.False(Result<int>.AnyFailed());
-    }
-
-
-
-    [Fact]
-    public void AnyFailed_when_passed_empty_list_returns_false()
-    {
-        Assert.False(Result<int>.AnyFailed(Array.Empty<Result>()));
-    }
-
-
-
-    [Fact]
-    public void AnyFailed_when_all_results_succeeded_returns_false()
-    {
-        var result1 = Result<int>.Success();
-        var result2 = Result<int>.Success();
-        var result3 = Result<int>.Success();
-
-        Assert.False(Result<int>.AnyFailed(result1, result2, result3));
-    }
-
-
-
-    [Fact]
-    public void AnyFailed_when_at_least_one_result_failed_returns_true()
-    {
-        var result1 = Result<int>.Success();
-        var result2 = Result<int>.Failure("Test error");
-        var result3 = Result<int>.Success();
-
-        Assert.True(Result<int>.AnyFailed(result1, result2, result3));
-    }
-
-
-
-    [Fact]
-    public void Flatten_when_passed_null_throws_ArgumentNullException()
-    {
-        var ex = Assert.Throws<ArgumentNullException>(() => Result<int>.Flatten(null!));
-        Assert.Equal("results", ex.ParamName);
-    }
-
-
-
-    [Fact]
-    public void Flatten_when_passed_nothing_returns_new_successful_Result()
-    {
-        var result = Result<int>.Flatten();
-
-        Assert.True(result.Succeeded);
-        Assert.False(result.Failed);
-        Assert.NotNull(result.ErrorMessage);
-        Assert.Empty(result.ErrorMessage);
-    }
-
-
-
-    [Fact]
-    public void Flatten_when_passed_empty_list_returns_new_successful_Result()
-    {
-        var result = Result<int>.Flatten(Array.Empty<Result>());
-
-        Assert.True(result.Succeeded);
-        Assert.False(result.Failed);
-        Assert.NotNull(result.ErrorMessage);
-        Assert.Empty(result.ErrorMessage);
-    }
-
-
-
-    [Fact]
-    public void Flatten_when_all_results_succeeded_returns_new_successful_Result()
-    {
-        var result1 = Result<int>.Success();
-        var result2 = Result<int>.Success();
-        var result3 = Result<int>.Success();
-
-        var result = Result<int>.Flatten(result1, result2, result3);
-
-        Assert.True(result.Succeeded);
-        Assert.False(result.Failed);
-        Assert.NotNull(result.ErrorMessage);
-        Assert.Empty(result.ErrorMessage);
-    }
-
-
-
-    [Fact]
-    public void Flatten_when_at_least_one_result_failed_returns_first_failed_Result()
-    {
-        var result1 = Result<int>.Success();
-        var result2 = Result<int>.Failure("test error");
-        var result3 = Result<int>.Success();
-
-        var result = Result<int>.Flatten(result1, result2, result3);
-
-        Assert.False(result.Succeeded);
-        Assert.True(result.Failed);
-        Assert.Equal("test error", result.ErrorMessage);
-    }
-
-
-
-
-    [Fact]
-    public void Flatten_when_multiple_results_failed_returns_Result_with_all_message()
-    {
-        var result1 = Result<int>.Success();
-        var result2 = Result<int>.Failure("test error 1");
-        var result3 = Result<int>.Failure("test error 2");
-        var result4 = Result<int>.Success();
-
-        var result = Result<int>.Flatten(result1, result2, result3, result4);
-
-        Assert.False(result.Succeeded);
-        Assert.True(result.Failed);
-        Assert.Equal("test error 1\ntest error 2", result.ErrorMessage);
-    }
-
+    // Note: AllSucceeded / AnyFailed / Flatten are inherited from Result and
+    // are already covered by ResultTests. Tests that invoked them via the
+    // derived type `Result<int>.` were just verifying inheritance, which is a
+    // language feature — they have been removed.
 }
\ No newline at end of file
diff --git a/tests/Wolfgang.TryPattern.Tests/ResultTests.cs b/tests/Wolfgang.TryPattern.Tests/ResultTests.cs
index 6d599d2..99d6e35 100644
--- a/tests/Wolfgang.TryPattern.Tests/ResultTests.cs
+++ b/tests/Wolfgang.TryPattern.Tests/ResultTests.cs
@@ -1,4 +1,3 @@
-#pragma warning disable IDE0022
 namespace Wolfgang.TryPattern.Tests;
 
 public class ResultTests
@@ -259,6 +258,23 @@ public void Flatten_when_at_least_one_result_failed_returns_first_failed_Result(
 
 
 
+    [Fact]
+    public void Flatten_when_multiple_results_failed_returns_Result_with_all_messages()
+    {
+        var result1 = Result.Success();
+        var result2 = Result.Failure("test error 1");
+        var result3 = Result.Failure("test error 2");
+        var result4 = Result.Success();
+
+        var result = Result.Flatten(result1, result2, result3, result4);
+
+        Assert.False(result.Succeeded);
+        Assert.True(result.Failed);
+        Assert.Equal("test error 1\ntest error 2", result.ErrorMessage);
+    }
+
+
+
 
 
 
diff --git a/tests/Wolfgang.TryPattern.Tests/RunAsyncFuncTests.cs b/tests/Wolfgang.TryPattern.Tests/RunAsyncFuncTests.cs
index e838536..70d2805 100644
--- a/tests/Wolfgang.TryPattern.Tests/RunAsyncFuncTests.cs
+++ b/tests/Wolfgang.TryPattern.Tests/RunAsyncFuncTests.cs
@@ -6,398 +6,398 @@ namespace Wolfgang.TryPattern.Tests;
 
 public class RunAsyncFuncTests
 {
-	[Fact]
-	public async Task RunAsync_Func_when_passed_null_throws_ArgumentNullException()
-	{
-		// Arrange
-		Func<Task<int>>? nullFunction = null;
-
-		// Act & Assert
-		await Assert.ThrowsAsync<ArgumentNullException>(() => Try.RunAsync(nullFunction!));
-	}
-
-	[Fact]
-	public async Task RunAsync_Func_int_when_successful_returns_successful_Result()
-	{
-		// Arrange
-		const int expectedValue = 42;
-
-		static async Task<int> Function()
-		{
-			await Task.Yield();
-			return expectedValue;
-		}
-
-		// Act
-		var result = await Try.RunAsync((Func<Task<int>>)Function);
-
-		// Assert
-		Assert.True(result.Succeeded);
-		Assert.False(result.Failed);
-		Assert.NotNull(result.ErrorMessage);
-		Assert.Empty(result.ErrorMessage);
-		Assert.Equal(expectedValue, result.Value);
-	}
-
-
-
-	[Fact]
-	public async Task RunAsync_Func_nullable_int_when_successful_returns_successful_Result()
-	{
-		// Arrange
-		int? expectedValue = 42;
-
-		async Task<int?> Function()
-		{
-			await Task.Yield();
-			return expectedValue;
-		}
-
-		// Act
-		var result = await Try.RunAsync((Func<Task<int?>>)Function);
-
-		// Assert
-		Assert.True(result.Succeeded);
-		Assert.False(result.Failed);
-		Assert.NotNull(result.ErrorMessage);
-		Assert.Empty(result.ErrorMessage);
-		Assert.Equal(expectedValue, result.Value);
-	}
-
-
-
-	[Fact]
-	public async Task RunAsync_Func_string_when_successful_returns_successful_Result()
-	{
-		// Arrange
-		const string expectedValue = "Hello, Async World!";
-
-		static async Task<string?> Function()
-		{
-			await Task.Yield();
-			return expectedValue;
-		}
-
-		// Act
-		var result = await Try.RunAsync(Function);
-
-		// Assert
-		Assert.True(result.Succeeded);
-		Assert.False(result.Failed);
-		Assert.Empty(result.ErrorMessage!);
-		Assert.Equal(expectedValue, result.Value);
-	}
-
-
-
-	[Fact]
-	public async Task RunAsync_Func_int_when_exception_is_thrown_returns_failed_Result_with_correct_properties()
-	{
-		// Arrange
-		static async Task<int> Function()
-		{
-			await Task.Yield();
-			throw new InvalidOperationException("Test exception");
-		}
-
-		// Act
-		var result = await Try.RunAsync((Func<Task<int>>)Function);
-
-		// Assert
-		Assert.False(result.Succeeded);
-		Assert.True(result.Failed);
-		Assert.Equal("Test exception", result.ErrorMessage);
-		var ex = Assert.Throws<InvalidOperationException>(() => result.Value);
-		Assert.Equal("Cannot access the Value of a failed Result.", ex.Message);
-	}
-
-
-
-	[Fact]
-	public async Task RunAsync_Func_nullable_int_when_exception_is_thrown_returns_failed_Result_with_correct_properties()
-	{
-		// Arrange
-		static async Task<int?> Function()
-		{
-			await Task.Yield();
-			throw new InvalidOperationException("Test exception");
-		}
-
-		// Act
-		var result = await Try.RunAsync((Func<Task<int?>>)Function);
-
-		// Assert
-		Assert.False(result.Succeeded);
-		Assert.True(result.Failed);
-		Assert.NotNull(result.ErrorMessage);
-		Assert.NotEmpty(result.ErrorMessage);
-		var ex = Assert.Throws<InvalidOperationException>(() => result.Value);
-		Assert.Equal("Cannot access the Value of a failed Result.", ex.Message);
-	}
+    [Fact]
+    public async Task RunAsync_Func_when_passed_null_throws_ArgumentNullException()
+    {
+        // Arrange
+        Func<Task<int>>? nullFunction = null;
+
+        // Act & Assert
+        await Assert.ThrowsAsync<ArgumentNullException>(() => Try.RunAsync(nullFunction!));
+    }
+
+    [Fact]
+    public async Task RunAsync_Func_int_when_successful_returns_successful_Result()
+    {
+        // Arrange
+        const int expectedValue = 42;
+
+        static async Task<int> Function()
+        {
+            await Task.Yield();
+            return expectedValue;
+        }
+
+        // Act
+        var result = await Try.RunAsync((Func<Task<int>>)Function);
+
+        // Assert
+        Assert.True(result.Succeeded);
+        Assert.False(result.Failed);
+        Assert.NotNull(result.ErrorMessage);
+        Assert.Empty(result.ErrorMessage);
+        Assert.Equal(expectedValue, result.Value);
+    }
+
+
+
+    [Fact]
+    public async Task RunAsync_Func_nullable_int_when_successful_returns_successful_Result()
+    {
+        // Arrange
+        int? expectedValue = 42;
+
+        async Task<int?> Function()
+        {
+            await Task.Yield();
+            return expectedValue;
+        }
+
+        // Act
+        var result = await Try.RunAsync((Func<Task<int?>>)Function);
+
+        // Assert
+        Assert.True(result.Succeeded);
+        Assert.False(result.Failed);
+        Assert.NotNull(result.ErrorMessage);
+        Assert.Empty(result.ErrorMessage);
+        Assert.Equal(expectedValue, result.Value);
+    }
+
+
+
+    [Fact]
+    public async Task RunAsync_Func_string_when_successful_returns_successful_Result()
+    {
+        // Arrange
+        const string expectedValue = "Hello, Async World!";
+
+        static async Task<string?> Function()
+        {
+            await Task.Yield();
+            return expectedValue;
+        }
+
+        // Act
+        var result = await Try.RunAsync(Function);
+
+        // Assert
+        Assert.True(result.Succeeded);
+        Assert.False(result.Failed);
+        Assert.Empty(result.ErrorMessage!);
+        Assert.Equal(expectedValue, result.Value);
+    }
+
+
+
+    [Fact]
+    public async Task RunAsync_Func_int_when_exception_is_thrown_returns_failed_Result_with_correct_properties()
+    {
+        // Arrange
+        static async Task<int> Function()
+        {
+            await Task.Yield();
+            throw new InvalidOperationException("Test exception");
+        }
+
+        // Act
+        var result = await Try.RunAsync((Func<Task<int>>)Function);
+
+        // Assert
+        Assert.False(result.Succeeded);
+        Assert.True(result.Failed);
+        Assert.Equal("Test exception", result.ErrorMessage);
+        var ex = Assert.Throws<InvalidOperationException>(() => result.Value);
+        Assert.Equal("Cannot access the Value of a failed Result.", ex.Message);
+    }
+
+
+
+    [Fact]
+    public async Task RunAsync_Func_nullable_int_when_exception_is_thrown_returns_failed_Result_with_correct_properties()
+    {
+        // Arrange
+        static async Task<int?> Function()
+        {
+            await Task.Yield();
+            throw new InvalidOperationException("Test exception");
+        }
+
+        // Act
+        var result = await Try.RunAsync((Func<Task<int?>>)Function);
+
+        // Assert
+        Assert.False(result.Succeeded);
+        Assert.True(result.Failed);
+        Assert.NotNull(result.ErrorMessage);
+        Assert.NotEmpty(result.ErrorMessage);
+        var ex = Assert.Throws<InvalidOperationException>(() => result.Value);
+        Assert.Equal("Cannot access the Value of a failed Result.", ex.Message);
+    }
 
 
 
-	[Fact]
-	public async Task RunAsync_Func_string_when_exception_is_thrown_returns_failed_Result_with_correct_properties()
-	{
-		// Arrange
-		static async Task<string?> Function()
-		{
-			await Task.Yield();
-			throw new InvalidOperationException("Test exception");
-		}
+    [Fact]
+    public async Task RunAsync_Func_string_when_exception_is_thrown_returns_failed_Result_with_correct_properties()
+    {
+        // Arrange
+        static async Task<string?> Function()
+        {
+            await Task.Yield();
+            throw new InvalidOperationException("Test exception");
+        }
 
-		// Act
-		var result = await Try.RunAsync(Function);
+        // Act
+        var result = await Try.RunAsync(Function);
 
-		// Assert
-		Assert.False(result.Succeeded);
-		Assert.True(result.Failed);
-		Assert.NotNull(result.ErrorMessage);
-		Assert.NotEmpty(result.ErrorMessage);
-		var ex = Assert.Throws<InvalidOperationException>(() => result.Value);
-		Assert.Equal("Cannot access the Value of a failed Result.", ex.Message);
-	}
+        // Assert
+        Assert.False(result.Succeeded);
+        Assert.True(result.Failed);
+        Assert.NotNull(result.ErrorMessage);
+        Assert.NotEmpty(result.ErrorMessage);
+        var ex = Assert.Throws<InvalidOperationException>(() => result.Value);
+        Assert.Equal("Cannot access the Value of a failed Result.", ex.Message);
+    }
 
 
 
-	[Fact]
-	public async Task RunAsync_Func_CancellationToken_when_passed_null_throws_ArgumentNullException()
-	{
-		// Arrange
-		Func<Task<int>>? nullFunction = null;
-		var cts = new CancellationTokenSource();
+    [Fact]
+    public async Task RunAsync_Func_CancellationToken_when_passed_null_throws_ArgumentNullException()
+    {
+        // Arrange
+        Func<Task<int>>? nullFunction = null;
+        var cts = new CancellationTokenSource();
 
-		// Act & Assert
-		await Assert.ThrowsAsync<ArgumentNullException>(() => Try.RunAsync(nullFunction!, cts.Token));
-	}
+        // Act & Assert
+        await Assert.ThrowsAsync<ArgumentNullException>(() => Try.RunAsync(nullFunction!, cts.Token));
+    }
 
 
 
-	[Fact]
-	public async Task RunAsync_Func_CancellationToken_int_when_successful_returns_successful_Result()
-	{
-		// Arrange
-		const int expectedValue = 42;
+    [Fact]
+    public async Task RunAsync_Func_CancellationToken_int_when_successful_returns_successful_Result()
+    {
+        // Arrange
+        const int expectedValue = 42;
 
-		static async Task<int> Function()
-		{
-			await Task.Yield();
-			return expectedValue;
-		}
+        static async Task<int> Function()
+        {
+            await Task.Yield();
+            return expectedValue;
+        }
 
-		var cts = new CancellationTokenSource();
+        var cts = new CancellationTokenSource();
 
-		// Act
-		var result = await Try.RunAsync((Func<Task<int>>)Function, cts.Token);
-
-		// Assert
-		Assert.True(result.Succeeded);
-		Assert.False(result.Failed);
-		Assert.NotNull(result.ErrorMessage);
-		Assert.Empty(result.ErrorMessage);
-		Assert.Equal(expectedValue, result.Value);
-	}
+        // Act
+        var result = await Try.RunAsync((Func<Task<int>>)Function, cts.Token);
+
+        // Assert
+        Assert.True(result.Succeeded);
+        Assert.False(result.Failed);
+        Assert.NotNull(result.ErrorMessage);
+        Assert.Empty(result.ErrorMessage);
+        Assert.Equal(expectedValue, result.Value);
+    }
 
 
 
-	[Fact]
-	public async Task RunAsync_Func_CancellationToken_nullable_int_when_successful_returns_successful_Result()
-	{
-		// Arrange
-		int? expectedValue = 42;
+    [Fact]
+    public async Task RunAsync_Func_CancellationToken_nullable_int_when_successful_returns_successful_Result()
+    {
+        // Arrange
+        int? expectedValue = 42;
 
-		async Task<int?> Function()
-		{
-			await Task.Yield();
-			return expectedValue;
-		}
+        async Task<int?> Function()
+        {
+            await Task.Yield();
+            return expectedValue;
+        }
 
-		var cts = new CancellationTokenSource();
+        var cts = new CancellationTokenSource();
 
 
-		// Act
-		var result = await Try.RunAsync((Func<Task<int?>>)Function, cts.Token);
+        // Act
+        var result = await Try.RunAsync((Func<Task<int?>>)Function, cts.Token);
 
-		// Assert
-		Assert.True(result.Succeeded);
-		Assert.False(result.Failed);
-		Assert.NotNull(result.ErrorMessage);
-		Assert.Empty(result.ErrorMessage);
-		Assert.Equal(expectedValue, result.Value);
-	}
+        // Assert
+        Assert.True(result.Succeeded);
+        Assert.False(result.Failed);
+        Assert.NotNull(result.ErrorMessage);
+        Assert.Empty(result.ErrorMessage);
+        Assert.Equal(expectedValue, result.Value);
+    }
 
 
 
-	[Fact]
-	public async Task RunAsync_Func_CancellationToken_string_when_successful_returns_successful_Result()
-	{
-		// Arrange
-		const string expectedValue = "Hello, Async World!";
+    [Fact]
+    public async Task RunAsync_Func_CancellationToken_string_when_successful_returns_successful_Result()
+    {
+        // Arrange
+        const string expectedValue = "Hello, Async World!";
 
-		static async Task<string?> Function()
-		{
-			await Task.Yield();
-			return expectedValue;
-		}
+        static async Task<string?> Function()
+        {
+            await Task.Yield();
+            return expectedValue;
+        }
 
-		var cts = new CancellationTokenSource();
+        var cts = new CancellationTokenSource();
 
 
-		// Act
-		var result = await Try.RunAsync(Function, cts.Token);
+        // Act
+        var result = await Try.RunAsync(Function, cts.Token);
 
-		// Assert
-		Assert.True(result.Succeeded);
-		Assert.False(result.Failed);
-		Assert.Empty(result.ErrorMessage!);
-		Assert.Equal(expectedValue, result.Value);
-	}
+        // Assert
+        Assert.True(result.Succeeded);
+        Assert.False(result.Failed);
+        Assert.Empty(result.ErrorMessage!);
+        Assert.Equal(expectedValue, result.Value);
+    }
 
 
 
-	[Fact]
-	public async Task RunAsync_Func_CancellationToken_int_when_exception_is_thrown_returns_failed_Result_with_correct_properties()
-	{
-		// Arrange
-		static async Task<int> Function()
-		{
-			await Task.Yield();
-			throw new InvalidOperationException("Test exception");
-		}
+    [Fact]
+    public async Task RunAsync_Func_CancellationToken_int_when_exception_is_thrown_returns_failed_Result_with_correct_properties()
+    {
+        // Arrange
+        static async Task<int> Function()
+        {
+            await Task.Yield();
+            throw new InvalidOperationException("Test exception");
+        }
 
-		var cts = new CancellationTokenSource();
+        var cts = new CancellationTokenSource();
 
 
-		// Act
-		var result = await Try.RunAsync((Func<Task<int>>)Function, cts.Token);
+        // Act
+        var result = await Try.RunAsync((Func<Task<int>>)Function, cts.Token);
 
-		// Assert
-		Assert.False(result.Succeeded);
-		Assert.True(result.Failed);
-		Assert.Equal("Test exception", result.ErrorMessage);
-		var ex = Assert.Throws<InvalidOperationException>(() => result.Value);
-		Assert.Equal("Cannot access the Value of a failed Result.", ex.Message);
-	}
+        // Assert
+        Assert.False(result.Succeeded);
+        Assert.True(result.Failed);
+        Assert.Equal("Test exception", result.ErrorMessage);
+        var ex = Assert.Throws<InvalidOperationException>(() => result.Value);
+        Assert.Equal("Cannot access the Value of a failed Result.", ex.Message);
+    }
 
 
 
-	[Fact]
-	public async Task RunAsync_Func_CancellationToken_nullable_int_when_exception_is_thrown_returns_failed_Result_with_correct_properties()
-	{
-		// Arrange
-		static async Task<int?> Function()
-		{
-			await Task.Yield();
-			throw new InvalidOperationException("Test exception");
-		}
+    [Fact]
+    public async Task RunAsync_Func_CancellationToken_nullable_int_when_exception_is_thrown_returns_failed_Result_with_correct_properties()
+    {
+        // Arrange
+        static async Task<int?> Function()
+        {
+            await Task.Yield();
+            throw new InvalidOperationException("Test exception");
+        }
 
-		var cts = new CancellationTokenSource();
+        var cts = new CancellationTokenSource();
 
 
-		// Act
-		var result = await Try.RunAsync((Func<Task<int?>>)Function, cts.Token);
+        // Act
+        var result = await Try.RunAsync((Func<Task<int?>>)Function, cts.Token);
 
-		// Assert
-		Assert.False(result.Succeeded);
-		Assert.True(result.Failed);
-		Assert.NotNull(result.ErrorMessage);
-		Assert.NotEmpty(result.ErrorMessage);
-		var ex = Assert.Throws<InvalidOperationException>(() => result.Value);
-		Assert.Equal("Cannot access the Value of a failed Result.", ex.Message);
-	}
+        // Assert
+        Assert.False(result.Succeeded);
+        Assert.True(result.Failed);
+        Assert.NotNull(result.ErrorMessage);
+        Assert.NotEmpty(result.ErrorMessage);
+        var ex = Assert.Throws<InvalidOperationException>(() => result.Value);
+        Assert.Equal("Cannot access the Value of a failed Result.", ex.Message);
+    }
 
 
 
-	[Fact]
-	public async Task RunAsync_Func_CancellationToken_string_when_exception_is_thrown_returns_failed_Result_with_correct_properties()
-	{
-		// Arrange
-		static async Task<string?> Function()
-		{
-			await Task.Yield();
-			throw new InvalidOperationException("Test exception");
-		}
+    [Fact]
+    public async Task RunAsync_Func_CancellationToken_string_when_exception_is_thrown_returns_failed_Result_with_correct_properties()
+    {
+        // Arrange
+        static async Task<string?> Function()
+        {
+            await Task.Yield();
+            throw new InvalidOperationException("Test exception");
+        }
 
-		var cts = new CancellationTokenSource();
+        var cts = new CancellationTokenSource();
 
 
-		// Act
-		var result = await Try.RunAsync(Function, cts.Token);
+        // Act
+        var result = await Try.RunAsync(Function, cts.Token);
 
-		// Assert
-		Assert.False(result.Succeeded);
-		Assert.True(result.Failed);
-		Assert.NotNull(result.ErrorMessage);
-		Assert.NotEmpty(result.ErrorMessage);
-		var ex = Assert.Throws<InvalidOperationException>(() => result.Value);
-		Assert.Equal("Cannot access the Value of a failed Result.", ex.Message);
-	}
+        // Assert
+        Assert.False(result.Succeeded);
+        Assert.True(result.Failed);
+        Assert.NotNull(result.ErrorMessage);
+        Assert.NotEmpty(result.ErrorMessage);
+        var ex = Assert.Throws<InvalidOperationException>(() => result.Value);
+        Assert.Equal("Cannot access the Value of a failed Result.", ex.Message);
+    }
 
 
 
-	[Fact]
-	public async Task RunAsync_Func_CancellationToken_int_when_cancellation_is_requested_throws_TaskCanceledException()
-	{
-		// Arrange
-		using var cts = new CancellationTokenSource();
-		var functionStarted = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+    [Fact]
+    public async Task RunAsync_Func_CancellationToken_int_when_cancellation_is_requested_throws_TaskCanceledException()
+    {
+        // Arrange
+        using var cts = new CancellationTokenSource();
+        var functionStarted = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-		async Task<int> Function()
-		{
-			functionStarted.TrySetResult(true);
-			await Task.Delay(Timeout.Infinite, cts.Token);
-			return 42;
-		}
+        async Task<int> Function()
+        {
+            functionStarted.TrySetResult(true);
+            await Task.Delay(Timeout.Infinite, cts.Token);
+            return 42;
+        }
 
-		var task = Try.RunAsync((Func<Task<int>>)Function, cts.Token);
+        var task = Try.RunAsync((Func<Task<int>>)Function, cts.Token);
 
-		// Act
-		await functionStarted.Task;
-		cts.Cancel();
+        // Act
+        await functionStarted.Task;
+        cts.Cancel();
 
-		await Assert.ThrowsAsync<TaskCanceledException>(() => task);
-	}
+        await Assert.ThrowsAsync<TaskCanceledException>(() => task);
+    }
 
 
 
-	[Fact]
-	public async Task RunAsync_Func_when_token_is_already_canceled_throws_OperationCanceledException_without_invoking_function()
-	{
-		// Arrange
-		using var cts = new CancellationTokenSource();
-		cts.Cancel();
-		var wasInvoked = false;
+    [Fact]
+    public async Task RunAsync_Func_when_token_is_already_canceled_throws_OperationCanceledException_without_invoking_function()
+    {
+        // Arrange
+        using var cts = new CancellationTokenSource();
+        cts.Cancel();
+        var wasInvoked = false;
 
-		Task<int> Function()
-		{
-			wasInvoked = true;
-			return Task.FromResult(42);
-		}
+        Task<int> Function()
+        {
+            wasInvoked = true;
+            return Task.FromResult(42);
+        }
 
-		// Act & Assert
-		await Assert.ThrowsAsync<OperationCanceledException>(() => Try.RunAsync((Func<Task<int>>)Function, cts.Token));
-		Assert.False(wasInvoked, "function should not be invoked when the token is already canceled");
-	}
+        // Act & Assert
+        await Assert.ThrowsAsync<OperationCanceledException>(() => Try.RunAsync((Func<Task<int>>)Function, cts.Token));
+        Assert.False(wasInvoked, "function should not be invoked when the token is already canceled");
+    }
 
 
 
-	[Fact]
-	public async Task RunAsync_Func_nullable_when_token_is_already_canceled_throws_OperationCanceledException_without_invoking_function()
-	{
-		// Arrange
-		using var cts = new CancellationTokenSource();
-		cts.Cancel();
-		var wasInvoked = false;
+    [Fact]
+    public async Task RunAsync_Func_nullable_when_token_is_already_canceled_throws_OperationCanceledException_without_invoking_function()
+    {
+        // Arrange
+        using var cts = new CancellationTokenSource();
+        cts.Cancel();
+        var wasInvoked = false;
 
-		Task<int?> Function()
-		{
-			wasInvoked = true;
-			return Task.FromResult<int?>(42);
-		}
-
-		// Act & Assert
-		await Assert.ThrowsAsync<OperationCanceledException>(() => Try.RunAsync((Func<Task<int?>>)Function, cts.Token));
-		Assert.False(wasInvoked, "function should not be invoked when the token is already canceled");
-	}
+        Task<int?> Function()
+        {
+            wasInvoked = true;
+            return Task.FromResult<int?>(42);
+        }
+
+        // Act & Assert
+        await Assert.ThrowsAsync<OperationCanceledException>(() => Try.RunAsync((Func<Task<int?>>)Function, cts.Token));
+        Assert.False(wasInvoked, "function should not be invoked when the token is already canceled");
+    }
 }