public async Task WithReferences()
{
int MatchSome(int some) => some + 1;
int MatchNone() => 0;
var source = AsyncMaybe <int> .Some(1);
var result = await source.Match(some : MatchSome, none : MatchNone);
Assert.Equal(2, result);
}
public async Task WithReferences()
{
Task MatchSome(int some) => Task.CompletedTask;
Task MatchNone() => Task.CompletedTask;
var source = AsyncMaybe <int> .Some(1);
var result = await source.Match(someAsync : MatchSome, noneAsync : MatchNone);
Assert.Equal(Unit(), result);
}
public async Task OnSome_WithLambdaReturningAsyncNone_ReturnsSelf()
{
const int expected = 34;
// ReSharper disable once ConvertClosureToMethodGroup
var source = await AsyncMaybe <int> .Some(expected).Or(() => AsyncMaybe <int> .None());
var result = source.MustBeSome();
Assert.Equal(expected, result);
}
public async Task WithReferences()
{
Task <int> MatchSome(int some) => Task.FromResult(some + 1);
int MatchNone(None none) => 0;
var source = AsyncMaybe <int> .Some(1);
var result = await source.Match(someAsync : MatchSome, none : MatchNone);
Assert.Equal(2, result);
}
public async Task WhenFirstIsSome_AndSecondIsNone_UsingLambda_ReturnsNone()
{
const int firstValue = 23;
var first = AsyncMaybe <int> .Some(firstValue);
var second = AsyncMaybe <int> .None();
var result = await first.Zip(second, (f, s) => (first : f, second : s));
result.MustBeNone();
}
public async Task WithReferences()
{
Task <int> MatchSome(int some) => Task.FromResult(some + 1);
Task <int> MatchNone() => Task.FromResult(0);
var source = AsyncMaybe <int> .Some(1);
var result = await source.MatchAsync(MatchSome, MatchNone);
Assert.Equal(2, result);
}
public async Task WhenSome_ReturnsSingleItemEnumerable()
{
const int expectedValue = 230023;
var source = AsyncMaybe <int> .Some(expectedValue);
var result = await source.ToEnumerable();
var value = Assert.Single(result);
Assert.Equal(expectedValue, value);
}
public async Task Some_Map_Action_T_MethodReference_ReturnsSomeUnit()
{
Task Foo(int it) => Task.CompletedTask;
var source = AsyncMaybe <int> .Some(5);
var result = await source.MapAsync(Foo);
var unit = result.MustBeSome();
Assert.IsType <Unit>(unit);
}
public async Task OnNone_WithMethodReferenceReturningAsyncSome_ReturnsOther()
{
const int expected = 34;
AsyncMaybe <int> Other() => AsyncMaybe <int> .Some(expected);
var source = await AsyncMaybe <int> .None().Or(Other);
var result = source.MustBeSome();
Assert.Equal(expected, result);
}
public async Task OnSome_WithMethodReferenceReturningAsyncNone_ReturnsSelf()
{
const int expected = 34;
Task <AsyncMaybe <int> > Other() => Task.FromResult(AsyncMaybe <int> .None());
var source = await AsyncMaybe <int> .Some(expected).OrAsync(otherAsync: Other);
var result = source.MustBeSome();
Assert.Equal(expected, result);
}
public async Task WithSomeLambda_AndNoneReference()
{
void MatchNone()
{
}
var source = AsyncMaybe <int> .Some(1);
var result = await source.Match(some => { }, none : MatchNone);
Assert.Equal(Unit(), result);
}
public async Task WithSomeReference_AndNoneLambda()
{
void MatchSome(int some)
{
}
var source = AsyncMaybe <int> .Some(1);
var result = await source.Match(some : MatchSome, none : () => { });
Assert.Equal(Unit(), result);
}
public async Task WhenFirstIsSome_AndSecondIsNone_AndThirdIsSome_ReturnsNone()
{
var first = AsyncMaybe <int> .Some(451);
var second = AsyncMaybe <int> .None();
var third = AsyncMaybe <int> .Some(123);
var result = await first.Zip(second, third, (f, s, t) => (f, s, t));
result.MustBeNone();
}
public async Task WithNullZipper_ThrowsException()
{
var first = AsyncMaybe <int> .None();
var second = AsyncMaybe <int> .None();
var third = AsyncMaybe <int> .None();
var fourth = AsyncMaybe <int> .None();
// ReSharper disable once AssignNullToNotNullAttribute
await Assert.ThrowsAsync <ArgumentNullException>(async() => await first.Zip <int, int, int, int, object>(second, third, fourth, null));
}
public async Task OnNone_WithLambda_ReturnsOther()
{
const int expected = 79;
var source = Maybe <int> .None();
var other = AsyncMaybe <int> .Some(expected);
var result = await source.OrAsync(() => other);
var value = result.MustBeSome();
Assert.Equal(expected, value);
}
public async Task OnSome_ReturnsSource()
{
const int expected = 5;
var source = Maybe <int> .Some(expected);
var other = AsyncMaybe <int> .Some(79);
var result = await source.OrAsync(other);
var value = result.MustBeSome();
Assert.Equal(expected, value);
}
public async Task OnNone_WithMethodReference_ReturnsOther()
{
const int expected = 79;
AsyncMaybe <int> Other() => AsyncMaybe <int> .Some(expected);
var source = Maybe <int> .None();
var result = await source.OrAsync(Other);
var value = result.MustBeSome();
Assert.Equal(expected, value);
}
public async Task Some_Map_ActionMethodReference_ReturnsSomeUnit()
{
void Foo(int it)
{
}
var source = AsyncMaybe <int> .Some(5);
var result = await source.Map(Foo);
var unit = result.MustBeSome();
Assert.IsType <Unit>(unit);
}
public async Task FromMaybeSome()
{
var expectedValue = new object();
Maybe <object> source = Maybe <object> .Some(expectedValue);
AsyncMaybe <object> implicitAsync = source;
var isSome = await implicitAsync.IsSome;
var value = await implicitAsync.OrFail();
Assert.True(isSome);
Assert.Same(expectedValue, value);
}
public async Task WhenFirstIsSome_AndSecondIsSome_UsingLambda_ReturnsSome()
{
const int firstValue = 23;
var first = AsyncMaybe <int> .Some(firstValue);
const int secondValue = 6589;
var second = AsyncMaybe <int> .Some(secondValue);
var result = await first.Zip(second, (f, s) => (first : f, second : s));
var value = result.MustBeSome();
Assert.Equal(firstValue, value.first);
Assert.Equal(secondValue, value.second);
}
public async Task WhenAllAreSome_ReturnsSome()
{
const int firstValue = 23;
var first = AsyncMaybe <int> .Some(firstValue);
const int secondValue = 6589;
var second = AsyncMaybe <int> .Some(secondValue);
var result = await first.ZipAsync(second, (f, s) => Task.FromResult((first: f, second: s)));
var value = result.MustBeSome();
Assert.Equal(firstValue, value.first);
Assert.Equal(secondValue, value.second);
}
public async Task WithReferences()
{
void MatchSome(int some)
{
}
void MatchNone()
{
}
var source = AsyncMaybe <int> .Some(1);
var result = await source.Match(some : MatchSome, none : MatchNone);
Assert.Equal(Unit(), result);
}
public async Task WhenFirstIsSome_AndSecondIsSome_UsingMethodReference_ReturnsSome()
{
const int firstValue = 23;
var first = AsyncMaybe <int> .Some(firstValue);
const int secondValue = 6589;
var second = AsyncMaybe <int> .Some(secondValue);
ValueTuple <int, int> Zipper(int f, int s) => (f, s);
var result = await first.Zip(second, Zipper);
var value = result.MustBeSome();
Assert.Equal(firstValue, value.Item1);
Assert.Equal(secondValue, value.Item2);
}
public async Task WhenAllAreSome_UsingMethodReference_ReturnsSome()
{
const int firstValue = 23;
var first = AsyncMaybe <int> .Some(firstValue);
const int secondValue = 6589;
var second = AsyncMaybe <int> .Some(secondValue);
Task <ValueTuple <int, int> > Zipper(int f, int s) => Task.FromResult((f, s));
var result = await first.ZipAsync(second, Zipper);
var value = result.MustBeSome();
Assert.Equal(firstValue, value.Item1);
Assert.Equal(secondValue, value.Item2);
}
public async Task WhenAnyIsNone_ReturnsNone()
{
AsyncMaybe <int> CreateMaybe(int flag) => flag == 0 ? AsyncMaybe <int> .None() : AsyncMaybe <int> .Some(flag);
const int numberOfSources = 4;
const int numberOfStates = 2;
const int expectedSomeInvocations = 1;
var someInvocations = 0;
var expectedNoneInvocations = (int)Math.Pow(numberOfStates, numberOfSources) - expectedSomeInvocations;
var noneInvocations = 0;
foreach (var a in Enumerable.Range(0, 2))
{
foreach (var b in Enumerable.Range(0, 2))
{
foreach (var c in Enumerable.Range(0, 2))
{
foreach (var d in Enumerable.Range(0, 2))
{
var first = CreateMaybe(a);
var second = CreateMaybe(b);
var third = CreateMaybe(c);
var fourth = CreateMaybe(d);
if (await first.IsSome && await second.IsSome && await third.IsSome && await fourth.IsSome)
{
someInvocations++;
continue;
}
var result = await first.ZipAsync(second, third, fourth, (v1, v2, v3, v4) => Task.FromResult((v1, v2, v3, v4)));
result.MustBeNone();
noneInvocations++;
}
}
}
}
Assert.Equal(expectedNoneInvocations, noneInvocations);
Assert.Equal(expectedSomeInvocations, someInvocations);
}
public async Task WhenAllAreSome_ReturnsSome()
{
const int firstValue = 23;
var first = AsyncMaybe <int> .Some(firstValue);
const int secondValue = 6589;
var second = AsyncMaybe <int> .Some(secondValue);
const int thirdValue = 236589;
var third = AsyncMaybe <int> .Some(thirdValue);
var result = await first.ZipAsync(second, third, (v1, v2, v3) => Task.FromResult((v1, v2, v3)));
var value = result.MustBeSome();
Assert.Equal(firstValue, value.Item1);
Assert.Equal(secondValue, value.Item2);
Assert.Equal(thirdValue, value.Item3);
}
public async Task WhenFirstIsSome_AndSecondIsSome_AndThirdIsSome_ReturnsSome()
{
const int firstValue = 23;
var first = AsyncMaybe <int> .Some(firstValue);
const int secondValue = 6589;
var second = AsyncMaybe <int> .Some(secondValue);
const int thirdValue = 2136589;
var third = AsyncMaybe <int> .Some(thirdValue);
var result = await first.Zip(second, third, (f, s, t) => (first : f, second : s, third : t));
var value = result.MustBeSome();
Assert.Equal(firstValue, value.first);
Assert.Equal(secondValue, value.second);
Assert.Equal(thirdValue, value.third);
}
public async Task Sync_ReturningSome_WhenNone_ReturnsNone()
{
var isNone = await AsyncMaybe <int> .None().FlatMap(some => Some(some + 3)).IsNone;
Assert.True(isNone);
}
public async Task Async_ReturningAsyncSome_WhenNone_ReturnsNone()
{
var isNone = await AsyncMaybe <int> .None().FlatMapAsync(some => Task.FromResult(Some(some + 3).ToAsync())).IsNone;
Assert.True(isNone);
}
public async Task Sync_ReturningSome_UsingNoArgs_WhenNone_ReturnsNone()
{
var source = await AsyncMaybe <Unit> .None().FlatMapUnit(() => Maybe <int> .Some(3));
source.MustBeNone();
}
