// Copyright (c) The Geekeey Authors
// SPDX-License-Identifier: EUPL-1.2

using System.Globalization;

namespace Geekeey.Request.Result.Tests;

internal sealed class ResultTransformTests
{
	[Test]
	public async Task I_can_map_and_it_returns_success_for_success()
	{
		var start = Prelude.Success(2);
		var result = start.Map(value => value.ToString(CultureInfo.InvariantCulture));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo("2");
	}

	[Test]
	public async Task I_can_map_and_it_returns_failure_for_failure()
	{
		var start = Prelude.Failure<int>("error");
		var result = start.Map(value => value.ToString(CultureInfo.InvariantCulture));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_transform_result_with_then_and_it_returns_success_for_success_and_mapping_returning_success()
	{
		var start = Prelude.Success(2);
		var result = start.Then(value => Prelude.Success(value.ToString(CultureInfo.InvariantCulture)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo("2");
	}

	[Test]
	public async Task I_can_transform_result_with_then_and_it_returns_failure_for_success_and_mapping_returning_failure()
	{
		var start = Prelude.Success(2);
		var result = start.Then(_ => Prelude.Failure<string>("error"));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_transform_result_with_then_and_it_returns_failure_for_failure_and_mapping_returning_success()
	{
		var start = Prelude.Failure<int>("error");
		var result = start.Then(value => Prelude.Success(value.ToString(CultureInfo.InvariantCulture)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_transform_result_with_then_and_it_returns_failure_for_failure_and_mapping_returning_failure()
	{
		var start = Prelude.Failure<int>("error");
		var result = start.Then(_ => Prelude.Failure<int>("error 2"));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_map_and_it_returns_success_for_success_without_throwing()
	{
		var start = Prelude.Success(2);
		var result = start.TryMap(value => value.ToString(CultureInfo.InvariantCulture));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo("2");
	}

	[Test]
	public async Task I_can_try_map_and_it_returns_failure_for_failure_without_throwing()
	{
		var start = Prelude.Failure<int>("error");
		var result = start.TryMap(value => value.ToString(CultureInfo.InvariantCulture));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_map_and_it_returns_failure_for_success_with_throwing()
	{
		var start = Prelude.Success(2);
		var result = start.TryMap<string>(_ => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_map_and_it_returns_failure_for_failure_with_throwing()
	{
		var start = Prelude.Failure<int>("error");
		var result = start.TryMap<string>(_ => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error).IsTypeOf<StringError>();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_result_with_then_and_it_returns_success_for_success_and_mapping_returning_success()
	{
		var start = Prelude.Success(2);
		var result = start.ThenTry(value => Prelude.Success(value.ToString(CultureInfo.InvariantCulture)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo("2");
	}

	[Test]
	public async Task I_can_try_transform_result_with_then_and_it_returns_failure_for_success_and_mapping_returning_failure()
	{
		var start = Prelude.Success(2);
		var result = start.ThenTry(_ => Prelude.Failure<string>("error"));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_result_with_then_and_it_returns_failure_for_failure_and_mapping_returning_failure()
	{
		var start = Prelude.Failure<int>("error");
		var result = start.ThenTry(x => Prelude.Success(x.ToString(CultureInfo.InvariantCulture)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_result_with_then_and_it_returns_failure_for_success_and_mapping_throwing()
	{
		var start = Prelude.Success(2);
		var result = start.ThenTry<string>(_ => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_transform_result_with_then_and_it_returns_failure_for_failure_and_mapping_throwing()
	{
		var start = Prelude.Failure<int>("error");
		var result = start.ThenTry<string>(_ => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error).IsTypeOf<StringError>();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_map_async_and_it_returns_success_for_success()
	{
		var start = Prelude.Success(2);
		var result = await start.MapAsync(value => Task.FromResult(value.ToString(CultureInfo.InvariantCulture)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo("2");
	}

	[Test]
	public async Task I_can_map_async_and_it_returns_failure_for_failure()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.MapAsync(value => Task.FromResult(value.ToString(CultureInfo.InvariantCulture)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_transform_result_async_with_then_and_it_returns_success_for_success_and_mapping_returning_success()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenAsync(value => Task.FromResult(Prelude.Success(value.ToString(CultureInfo.InvariantCulture))));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo("2");
	}

	[Test]
	public async Task I_can_transform_result_async_with_then_and_it_returns_failure_for_success_and_mapping_returning_failure()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenAsync(_ => Task.FromResult(Prelude.Failure<string>("error")));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_returning_success()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.ThenAsync(value => Task.FromResult(Prelude.Success(value.ToString(CultureInfo.InvariantCulture))));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_returning_failure()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.ThenAsync(_ => Task.FromResult(Prelude.Failure<int>("error 2")));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_map_async_and_it_returns_success_for_success_without_throwing()
	{
		var start = Prelude.Success(2);
		var result = await start.TryMapAsync(value => Task.FromResult(value.ToString(CultureInfo.InvariantCulture)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo("2");
	}

	[Test]
	public async Task I_can_try_map_async_and_it_returns_failure_for_failure_without_throwing()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.TryMapAsync(value => Task.FromResult(value.ToString(CultureInfo.InvariantCulture)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_map_async_and_it_returns_failure_for_success_with_throwing()
	{
		var start = Prelude.Success(2);
		var result = await start.TryMapAsync(Task<string> (_) => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_map_async_and_it_returns_failure_for_success_with_await_throwing()
	{
		var start = Prelude.Success(2);
		var result = await start.TryMapAsync(async Task<string> (_) =>
		{
			await Task.CompletedTask;
			throw new CustomTestException();
		});

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_map_async_and_it_returns_failure_for_failure_with_throwing()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.TryMapAsync(Task<string> (_) => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error).IsTypeOf<StringError>();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_map_async_and_it_returns_failure_for_failure_with_await_throwing()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.TryMapAsync(async Task<string> (_) =>
		{
			await Task.CompletedTask;
			throw new CustomTestException();
		});

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error).IsTypeOf<StringError>();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_result_async_with_then_and_it_returns_success_for_success_and_mapping_returning_success()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenTryAsync(value => Task.FromResult(Prelude.Success(value.ToString(CultureInfo.InvariantCulture))));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo("2");
	}

	[Test]
	public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_success_and_mapping_returning_failure()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenTryAsync(_ => Task.FromResult(Prelude.Failure<string>("error")));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_returning_failure()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.ThenTryAsync(x => Task.FromResult(Prelude.Success(x.ToString(CultureInfo.InvariantCulture))));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_success_and_mapping_throwing()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenTryAsync(Task<Result<string>> (_) => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_success_and_mapping_await_throwing()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenTryAsync(async Task<Result<string>> (_) =>
		{
			await Task.CompletedTask;
			throw new CustomTestException();
		});

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_throwing()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.ThenTryAsync(Task<Result<string>> (_) => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error).IsTypeOf<StringError>();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_await_throwing()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.ThenTryAsync(async Task<Result<string>> (_) =>
		{
			await Task.CompletedTask;
			throw new CustomTestException();
		});

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error).IsTypeOf<StringError>();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_map_async_and_it_returns_success_for_success_ValueTask()
	{
		var start = Prelude.Success(2);
		var result = await start.MapAsync(value => ValueTask.FromResult(value.ToString(CultureInfo.InvariantCulture)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo("2");
	}

	[Test]
	public async Task I_can_map_async_and_it_returns_failure_for_failure_ValueTask()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.MapAsync(value => ValueTask.FromResult(value.ToString(CultureInfo.InvariantCulture)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_transform_result_async_with_then_and_it_returns_success_for_success_and_mapping_returning_success_ValueTask()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenAsync(value => ValueTask.FromResult(Prelude.Success(value.ToString(CultureInfo.InvariantCulture))));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo("2");
	}

	[Test]
	public async Task I_can_transform_result_async_with_then_and_it_returns_failure_for_success_and_mapping_returning_failure_ValueTask()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenAsync(_ => ValueTask.FromResult(Prelude.Failure<string>("error")));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_returning_success_ValueTask()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.ThenAsync(value => ValueTask.FromResult(Prelude.Success(value.ToString(CultureInfo.InvariantCulture))));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_returning_failure_ValueTask()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.ThenAsync(_ => ValueTask.FromResult(Prelude.Failure<int>("error 2")));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_map_async_and_it_returns_success_for_success_without_throwing_ValueTask()
	{
		var start = Prelude.Success(2);
		var result = await start.TryMapAsync(value => ValueTask.FromResult(value.ToString(CultureInfo.InvariantCulture)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo("2");
	}

	[Test]
	public async Task I_can_try_map_async_and_it_returns_failure_for_failure_without_throwing_ValueTask()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.TryMapAsync(value => ValueTask.FromResult(value.ToString(CultureInfo.InvariantCulture)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_map_async_and_it_returns_failure_for_success_with_throwing_ValueTask()
	{
		var start = Prelude.Success(2);
		var result = await start.TryMapAsync(ValueTask<string> (_) => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_map_async_and_it_returns_failure_for_success_with_await_throwing_ValueTask()
	{
		var start = Prelude.Success(2);
		var result = await start.TryMapAsync(async ValueTask<string> (_) =>
		{
			await ValueTask.CompletedTask;
			throw new CustomTestException();
		});

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_map_async_and_it_returns_failure_for_failure_with_throwing_ValueTask()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.TryMapAsync(ValueTask<string> (_) => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error).IsTypeOf<StringError>();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_map_async_and_it_returns_failure_for_failure_with_await_throwing_ValueTask()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.TryMapAsync(async ValueTask<string> (_) =>
		{
			await ValueTask.CompletedTask;
			throw new CustomTestException();
		});

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error).IsTypeOf<StringError>();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_result_async_with_then_and_it_returns_success_for_success_and_mapping_returning_success_ValueTask()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenTryAsync(value => ValueTask.FromResult(Prelude.Success(value.ToString(CultureInfo.InvariantCulture))));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo("2");
	}

	[Test]
	public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_success_and_mapping_returning_failure_ValueTask()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenTryAsync(_ => ValueTask.FromResult(Prelude.Failure<string>("error")));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_returning_failure_ValueTask()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.ThenTryAsync(x => ValueTask.FromResult(Prelude.Success(x.ToString(CultureInfo.InvariantCulture))));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_success_and_mapping_throwing_ValueTask()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenTryAsync(ValueTask<Result<string>> (_) => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_success_and_mapping_await_throwing_ValueTask()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenTryAsync(async ValueTask<Result<string>> (_) =>
		{
			await ValueTask.CompletedTask;
			throw new CustomTestException();
		});

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_throwing_ValueTask()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.ThenTryAsync(ValueTask<Result<string>> (_) => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error).IsTypeOf<StringError>();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_await_throwing_ValueTask()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.ThenTryAsync(async ValueTask<Result<string>> (_) =>
		{
			await ValueTask.CompletedTask;
			throw new CustomTestException();
		});

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error).IsTypeOf<StringError>();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_map_non_generic_result_and_it_returns_success_for_success()
	{
		var start = Prelude.Success();
		var result = start.Map(() => 42);

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo(42);
	}

	[Test]
	public async Task I_can_map_non_generic_result_and_it_returns_failure_for_failure()
	{
		var start = Prelude.Failure("error");
		var result = start.Map(() => 42);

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_map_non_generic_result_and_it_returns_failure_for_exception()
	{
		var start = Prelude.Success();
		var result = start.TryMap<int>(() => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_transform_non_generic_result_with_then_and_it_returns_success_for_success()
	{
		var start = Prelude.Success();
		var result = start.Then(Prelude.Success);

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
	}

	[Test]
	public async Task I_can_transform_non_generic_result_with_then_to_generic_and_it_returns_success_for_success()
	{
		var start = Prelude.Success();
		var result = start.Then(() => Prelude.Success(42));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo(42);
	}

	[Test]
	public async Task I_can_transform_generic_result_with_then_to_non_generic_and_it_returns_success_for_success()
	{
		var start = Prelude.Success(42);
		var result = start.Then(_ => Prelude.Success());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
	}

	[Test]
	public async Task I_can_map_non_generic_result_async_and_it_returns_success_for_success_Task()
	{
		var start = Prelude.Success();
		var result = await start.MapAsync(() => Task.FromResult(42));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo(42);
	}

	[Test]
	public async Task I_can_try_map_non_generic_result_async_and_it_returns_failure_for_exception_Task()
	{
		var start = Prelude.Success();
		var result = await start.TryMapAsync((Func<Task<int>>)(() => throw new CustomTestException()));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_transform_non_generic_result_async_with_then_and_it_returns_success_for_success_Task()
	{
		var start = Prelude.Success();
		var result = await start.ThenAsync(() => Task.FromResult(Prelude.Success()));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
	}

	[Test]
	public async Task I_can_transform_generic_result_async_with_then_to_non_generic_and_it_returns_success_for_success_Task()
	{
		var start = Prelude.Success(42);
		var result = await start.ThenAsync(_ => Task.FromResult(Prelude.Success()));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
	}

	[Test]
	public async Task I_can_map_non_generic_result_async_and_it_returns_success_for_success_ValueTask()
	{
		var start = Prelude.Success();
		var result = await start.MapAsync(() => ValueTask.FromResult(42));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo(42);
	}

	[Test]
	public async Task I_can_try_map_non_generic_result_async_and_it_returns_failure_for_exception_ValueTask()
	{
		var start = Prelude.Success();
		var result = await start.TryMapAsync((Func<ValueTask<int>>)(() => throw new CustomTestException()));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_transform_generic_result_async_with_then_to_non_generic_and_it_returns_success_for_success_ValueTask()
	{
		var start = Prelude.Success(42);
		var result = await start.ThenAsync(_ => ValueTask.FromResult(Prelude.Success()));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
	}

	[Test]
	public async Task I_can_try_transform_result_to_non_generic_and_it_returns_success_for_success()
	{
		var start = Prelude.Success(2);
		var result = start.ThenTry(value => Prelude.Success());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
	}

	[Test]
	public async Task I_can_try_transform_result_to_non_generic_and_it_returns_failure_for_success_and_mapping_returning_failure()
	{
		var start = Prelude.Success(2);
		var result = start.ThenTry(_ => Prelude.Failure("error"));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_result_to_non_generic_and_it_returns_failure_for_success_and_mapping_throwing()
	{
		var start = Prelude.Success(2);
		var result = start.ThenTry(_ => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_transform_result_async_to_non_generic_and_it_returns_success_for_success_Task()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenTryAsync(value => Task.FromResult(Prelude.Success()));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
	}

	[Test]
	public async Task I_can_try_transform_result_async_to_non_generic_and_it_returns_failure_for_success_and_mapping_throwing_Task()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenTryAsync(Task<Result> (_) => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_transform_result_async_to_non_generic_and_it_returns_success_for_success_ValueTask()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenTryAsync(value => ValueTask.FromResult(Prelude.Success()));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
	}

	[Test]
	public async Task I_can_try_transform_result_async_to_non_generic_and_it_returns_failure_for_success_and_mapping_throwing_ValueTask()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenTryAsync(ValueTask<Result> (_) => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_transform_non_generic_result_with_then_and_it_returns_success_for_success()
	{
		var start = Prelude.Success();
		var result = start.ThenTry(Prelude.Success);

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
	}

	[Test]
	public async Task I_can_try_transform_non_generic_result_with_then_and_it_returns_failure_for_exception()
	{
		var start = Prelude.Success();
		var result = start.ThenTry(() => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_transform_non_generic_result_with_then_to_generic_and_it_returns_success_for_success()
	{
		var start = Prelude.Success();
		var result = start.ThenTry(() => Prelude.Success(42));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo(42);
	}

	[Test]
	public async Task I_can_try_transform_non_generic_result_with_then_to_generic_and_it_returns_failure_for_exception()
	{
		var start = Prelude.Success();
		var result = start.ThenTry<int>(() => throw new CustomTestException());

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_map_non_generic_result_async_and_it_returns_failure_for_failure_Task()
	{
		var start = Prelude.Failure("error");
		var result = await start.MapAsync(() => Task.FromResult(42));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_map_non_generic_result_async_and_it_returns_success_for_success_Task()
	{
		var start = Prelude.Success();
		var result = await start.TryMapAsync(() => Task.FromResult(42));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo(42);
	}

	[Test]
	public async Task I_can_try_map_non_generic_result_async_and_it_returns_failure_for_failure_Task()
	{
		var start = Prelude.Failure("error");
		var result = await start.TryMapAsync(() => Task.FromResult(42));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_map_non_generic_result_async_and_it_returns_failure_for_await_exception_Task()
	{
		var start = Prelude.Success();
		var result = await start.TryMapAsync((Func<Task<int>>)(async () =>
		{
			await Task.CompletedTask;
			throw new CustomTestException();
		}));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_transform_non_generic_result_async_with_then_and_it_returns_failure_for_failure_Task()
	{
		var start = Prelude.Failure("error");
		var result = await start.ThenAsync(() => Task.FromResult(Prelude.Success()));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_non_generic_result_async_with_then_and_it_returns_success_for_success_Task()
	{
		var start = Prelude.Success();
		var result = await start.ThenTryAsync(() => Task.FromResult(Prelude.Success()));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
	}

	[Test]
	public async Task I_can_try_transform_non_generic_result_async_with_then_and_it_returns_failure_for_exception_Task()
	{
		var start = Prelude.Success();
		var result = await start.ThenTryAsync((Func<Task<Result>>)(() => throw new CustomTestException()));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_transform_non_generic_result_async_with_then_and_it_returns_failure_for_await_exception_Task()
	{
		var start = Prelude.Success();
		var result = await start.ThenTryAsync((Func<Task<Result>>)(async () =>
		{
			await Task.CompletedTask;
			throw new CustomTestException();
		}));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_transform_non_generic_result_async_with_then_to_generic_and_it_returns_success_for_success_Task()
	{
		var start = Prelude.Success();
		var result = await start.ThenAsync(() => Task.FromResult(Prelude.Success(42)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo(42);
	}

	[Test]
	public async Task I_can_transform_non_generic_result_async_with_then_to_generic_and_it_returns_failure_for_failure_Task()
	{
		var start = Prelude.Failure("error");
		var result = await start.ThenAsync(() => Task.FromResult(Prelude.Success(42)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_non_generic_result_async_with_then_to_generic_and_it_returns_success_for_success_Task()
	{
		var start = Prelude.Success();
		var result = await start.ThenTryAsync(() => Task.FromResult(Prelude.Success(42)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo(42);
	}

	[Test]
	public async Task I_can_try_transform_non_generic_result_async_with_then_to_generic_and_it_returns_failure_for_exception_Task()
	{
		var start = Prelude.Success();
		var result = await start.ThenTryAsync((Func<Task<Result<int>>>)(() => throw new CustomTestException()));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_transform_non_generic_result_async_with_then_to_generic_and_it_returns_failure_for_await_exception_Task()
	{
		var start = Prelude.Success();
		var result = await start.ThenTryAsync((Func<Task<Result<int>>>)(async () =>
		{
			await Task.CompletedTask;
			throw new CustomTestException();
		}));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_transform_generic_result_async_with_then_to_non_generic_and_it_returns_failure_for_failure_ValueTask()
	{
		var start = Prelude.Failure<int>("error");
		var result = await start.ThenAsync(_ => ValueTask.FromResult(Prelude.Success()));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_result_async_to_non_generic_and_it_returns_failure_for_success_and_mapping_returning_failure_ValueTask()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenTryAsync(_ => ValueTask.FromResult(Prelude.Failure("error")));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_result_async_to_non_generic_and_it_returns_failure_for_success_and_mapping_await_throwing_ValueTask()
	{
		var start = Prelude.Success(2);
		var result = await start.ThenTryAsync(async ValueTask<Result> (_) =>
		{
			await ValueTask.CompletedTask;
			throw new CustomTestException();
		});

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_map_non_generic_result_async_and_it_returns_failure_for_failure_ValueTask()
	{
		var start = Prelude.Failure("error");
		var result = await start.MapAsync(() => ValueTask.FromResult(42));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_map_non_generic_result_async_and_it_returns_success_for_success_ValueTask()
	{
		var start = Prelude.Success();
		var result = await start.TryMapAsync(() => ValueTask.FromResult(42));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo(42);
	}

	[Test]
	public async Task I_can_try_map_non_generic_result_async_and_it_returns_failure_for_failure_ValueTask()
	{
		var start = Prelude.Failure("error");
		var result = await start.TryMapAsync(() => ValueTask.FromResult(42));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_map_non_generic_result_async_and_it_returns_failure_for_await_exception_ValueTask()
	{
		var start = Prelude.Success();
		var result = await start.TryMapAsync((Func<ValueTask<int>>)(async () =>
		{
			await ValueTask.CompletedTask;
			throw new CustomTestException();
		}));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_transform_non_generic_result_async_with_then_and_it_returns_success_for_success_ValueTask()
	{
		var start = Prelude.Success();
		var result = await start.ThenAsync(() => ValueTask.FromResult(Prelude.Success()));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
	}

	[Test]
	public async Task I_can_transform_non_generic_result_async_with_then_and_it_returns_failure_for_failure_ValueTask()
	{
		var start = Prelude.Failure("error");
		var result = await start.ThenAsync(() => ValueTask.FromResult(Prelude.Success()));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_non_generic_result_async_with_then_and_it_returns_success_for_success_ValueTask()
	{
		var start = Prelude.Success();
		var result = await start.ThenTryAsync(() => ValueTask.FromResult(Prelude.Success()));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
	}

	[Test]
	public async Task I_can_try_transform_non_generic_result_async_with_then_and_it_returns_failure_for_exception_ValueTask()
	{
		var start = Prelude.Success();
		var result = await start.ThenTryAsync((Func<ValueTask<Result>>)(() => throw new CustomTestException()));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_transform_non_generic_result_async_with_then_and_it_returns_failure_for_await_exception_ValueTask()
	{
		var start = Prelude.Success();
		var result = await start.ThenTryAsync((Func<ValueTask<Result>>)(async () =>
		{
			await ValueTask.CompletedTask;
			throw new CustomTestException();
		}));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_transform_non_generic_result_async_with_then_to_generic_and_it_returns_success_for_success_ValueTask()
	{
		var start = Prelude.Success();
		var result = await start.ThenAsync(() => ValueTask.FromResult(Prelude.Success(42)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo(42);
	}

	[Test]
	public async Task I_can_transform_non_generic_result_async_with_then_to_generic_and_it_returns_failure_for_failure_ValueTask()
	{
		var start = Prelude.Failure("error");
		var result = await start.ThenAsync(() => ValueTask.FromResult(Prelude.Success(42)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		await Assert.That(result.Error?.Message).IsEqualTo("error");
	}

	[Test]
	public async Task I_can_try_transform_non_generic_result_async_with_then_to_generic_and_it_returns_success_for_success_ValueTask()
	{
		var start = Prelude.Success();
		var result = await start.ThenTryAsync(() => ValueTask.FromResult(Prelude.Success(42)));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsTrue();
		await Assert.That(result.Value).IsEqualTo(42);
	}

	[Test]
	public async Task I_can_try_transform_non_generic_result_async_with_then_to_generic_and_it_returns_failure_for_exception_ValueTask()
	{
		var start = Prelude.Success();
		var result = await start.ThenTryAsync((Func<ValueTask<Result<int>>>)(() => throw new CustomTestException()));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}

	[Test]
	public async Task I_can_try_transform_non_generic_result_async_with_then_to_generic_and_it_returns_failure_for_await_exception_ValueTask()
	{
		var start = Prelude.Success();
		var result = await start.ThenTryAsync((Func<ValueTask<Result<int>>>)(async () =>
		{
			await ValueTask.CompletedTask;
			throw new CustomTestException();
		}));

		using var scope = Assert.Multiple();
		await Assert.That(result.IsSuccess).IsFalse();
		var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
		await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
	}
}