public async Task OnNone_WithLambdaReturningAsyncNone_ReturnsNone()
{
// ReSharper disable once ConvertClosureToMethodGroup
var source = await AsyncMaybe <int> .None().OrAsync(() => Task.FromResult(AsyncMaybe <int> .None()));
source.MustBeNone();
}
public async Task OnNone_WithMethodReferenceReturningAsyncNone_ReturnsNone()
{
AsyncMaybe <int> None() => AsyncMaybe <int> .None();
var source = await AsyncMaybe <int> .None().Or(None);
source.MustBeNone();
}
public async Task None()
{
var source = AsyncMaybe <object> .None();
var isNone = await source.IsNone;
Assert.True(isNone);
}
public async Task WhenNone_ReturnsEmptyEnumerable()
{
var source = AsyncMaybe <int> .None();
var result = await source.ToEnumerable();
Assert.Empty(result);
}
public async Task OnNone_WithMethodReferenceReturningAsyncNone_ReturnsNone()
{
Task <AsyncMaybe <int> > None() => Task.FromResult(AsyncMaybe <int> .None());
var source = await AsyncMaybe <int> .None().OrAsync(otherAsync: None);
source.MustBeNone();
}
public async Task Async_OnNone_WithFalsePredicate_ReturnsNone()
{
var rec = new Recorder();
var source = await AsyncMaybe <object> .None()
.FilterAsync(rec.Record(async(object it) => await Task.FromResult(false)));
source.MustBeNone();
rec.MustHaveExactly(0.Invocations());
}
public async Task OnSome_WithAsyncNone_ReturnsSelf()
{
const int expected = 34;
var source = await AsyncMaybe <int> .Some(expected).Or(AsyncMaybe <int> .None());
var result = source.MustBeSome();
Assert.Equal(expected, result);
}
public async Task WithNullZipper_ThrowsException()
{
var first = AsyncMaybe <int> .None();
var second = AsyncMaybe <int> .None();
// ReSharper disable once AssignNullToNotNullAttribute
await Assert.ThrowsAsync <ArgumentNullException>(async() => await first.Zip <int, int, object>(second, null));
}
public async Task Async_OnNone_WithFalsePredicate_ReturnsNone()
{
var invocations = 0;
var source = await AsyncMaybe <object> .None()
.WhereAsync(async it => { invocations++; return(await Task.FromResult(false)); });
source.MustBeNone();
Assert.Equal(0, invocations);
}
public async Task OnNone_WithLambdaReturningAsyncSome_ReturnsOther()
{
const int expected = 34;
var source = await AsyncMaybe <int> .None().OrAsync(() => Task.FromResult(AsyncMaybe <int> .Some(expected)));
var result = source.MustBeSome();
Assert.Equal(expected, result);
}
public async Task NoneValue_WithLambdas()
{
var invocations = 0;
var source = AsyncMaybe <int> .None();
var result = await source.MatchAsync(some => Task.FromResult(some + 1), none => { invocations++; return(Task.FromResult(0)); });
Assert.Equal(0, result);
Assert.Equal(1, invocations);
}
public async Task Sync_OnNone_returnsSameAsMap()
{
var source = AsyncMaybe <int> .None();
var where = await source.Select(it => it * 2);
var map = await source.Map(it => it * 2);
Assert.Equal(where, map);
}
public async Task Async_OnNone_ReturnsSameAsMapAsync()
{
var source = AsyncMaybe <int> .None();
var where = await source.SelectAsync(it => Task.FromResult(it * 2));
var map = await source.MapAsync(it => Task.FromResult(it * 2));
Assert.Equal(where, map);
}
public async Task WhenFirstIsNone_AndSecondIsNone_UsingLambda_ReturnsNone()
{
var first = AsyncMaybe <int> .None();
var second = AsyncMaybe <int> .None();
var result = await first.Zip(second, (f, s) => (first : f, second : s));
result.MustBeNone();
}
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 NoneValue_WithLambdas()
{
var some = 0;
var none = 0;
var source = AsyncMaybe <int> .None();
await source.Match(_ => { some++; return(TaskCache.CompletedTask); }, _ => { none++; return(TaskCache.CompletedTask); });
Assert.Equal(0, some);
Assert.Equal(1, none);
}
public async Task NoneValue_WithLambdas()
{
var some = 0;
var none = 0;
var source = AsyncMaybe <int> .None();
await source.Match(value => { some++; }, none : () => { none++; });
Assert.Equal(0, some);
Assert.Equal(1, none);
}
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 OnNone_WithMethodReferenceReturningAsyncSome_ReturnsOther()
{
const int expected = 34;
Task <AsyncMaybe <int> > Other() => Task.FromResult(AsyncMaybe <int> .Some(expected));
var source = await AsyncMaybe <int> .None().OrAsync(otherAsync: Other);
var result = source.MustBeSome();
Assert.Equal(expected, result);
}
public async Task WithSomeLambda_AndNoneReference()
{
var some = 0;
var none = 0;
void MatchNone(None _) => none++;
var source = AsyncMaybe <int> .None();
await source.Match(_ => { some++; }, none : MatchNone);
Assert.Equal(0, some);
Assert.Equal(1, none);
}
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 WithAsyncNoneNone_ReturnsNone()
{
var source = await AsyncMaybe <int> .None().Map(it => AsyncMaybe <int> .None()).Flatten();
source.MustBeNone();
}
public async Task WithNoneSome_ReturnsNone()
{
var source = await AsyncMaybe <int> .None().Map(it => Maybe <int> .Some(1)).Flatten();
source.MustBeNone();
}
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 OnNone_WithAsyncNone_ReturnsNone()
{
var source = await AsyncMaybe <int> .None().OrAsync(Task.FromResult(AsyncMaybe <int> .None()));
source.MustBeNone();
}
public async Task Sync_OnNone_WithFalsePredicate_ReturnsNone()
{
var source = await AsyncMaybe <object> .None().Filter(it => false);
source.MustBeNone();
}
public async Task Async_OnNone_WithFunction_ThrowsException()
{
var source = AsyncMaybe <int> .None();
await Assert.ThrowsAsync <ExpectedException>(() => source.OrThrowAsync(() => Task.FromResult <Exception>(new ExpectedException())));
}
public async Task Sync_WhenNone_ReturnsNone()
{
var isNone = await AsyncMaybe <int> .None().Map(some => some + 3).IsNone;
Assert.True(isNone);
}
public async Task None()
{
var source = await AsyncMaybe <int> .None();
source.MustBeNone();
}
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);
}
