public async Task Sync_ReturningAsyncNoneUsingLambda_UsingNoArgs_WhenSome_ReturnsNone() { // ReSharper disable once ConvertClosureToMethodGroup var source = await AsyncMaybe <Unit> .Some(new Unit()).FlatMapUnit(() => AsyncMaybe <int> .None()); source.MustBeNone(); }
public async Task OnNone_WithLambdaReturningAsyncNone_ReturnsNone() { // ReSharper disable once ConvertClosureToMethodGroup var source = await AsyncMaybe <int> .None().Or(() => AsyncMaybe <int> .None()); source.MustBeNone(); }
public async Task None_Map_Action_T__ReturnsNoneUnit() { var source = AsyncMaybe <int> .None(); var result = await source.MapAsync(it => Task.CompletedTask); result.MustBeNone(); }
public async Task None() { var source = AsyncMaybe <object> .None(); var isNone = await source.IsNone; Assert.True(isNone); }
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_Map_Action_ReturnsNoneUnit() { var source = AsyncMaybe <int> .None(); var result = await source.Map(it => { }); result.MustBeNone(); }
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 WhenNone_ReturnsEmptyEnumerable() { var source = AsyncMaybe <int> .None(); var result = await source.ToEnumerable(); Assert.Empty(result); }
public async Task OnNone_WithAsyncSome_ReturnsOther() { const int expected = 34; var source = await AsyncMaybe <int> .None().Or(AsyncMaybe <int> .Some(expected)); var result = source.MustBeSome(); Assert.Equal(expected, result); }
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 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 OnNone_WithLambdaReturningSome_ReturnsOther() { const int expected = 34; var source = await AsyncMaybe <int> .None().OrAsync(() => Task.FromResult(Maybe <int> .Some(expected))); var result = source.MustBeSome(); Assert.Equal(expected, result); }
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 None_Map_Action_T__ActionIsNotInvoked() { var rec = new Recorder(); var source = AsyncMaybe <int> .None(); var result = await source.MapAsync(rec.Record((int it) => Task.CompletedTask)); result.MustBeNone(); rec.MustHaveExactly(0.Invocations()); }
public async Task NoneValue_WithLambdas() { var invocations = 0; var source = AsyncMaybe <int> .None(); var result = await source.Match(some => { }, none : () => { invocations++; }); Assert.Equal(Unit(), result); Assert.Equal(1, invocations); }
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 NoneValue_WithLambdas() { var invocations = 0; var source = AsyncMaybe <int> .None(); var result = await source.Match(some => Task.FromResult(some + 1), none => { invocations++; return(0); }); Assert.Equal(0, result); Assert.Equal(1, invocations); }
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 None_Select_ReturnsSameAsMap() { var source = AsyncMaybe <int> .None(); var where = await source.Select(it => { }); var map = await source.Map(it => { }); Assert.Equal(where, map); }
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 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 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 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 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 Sync_ReturningSome_UsingNoArgs_WhenNone_ReturnsNone() { var source = await AsyncMaybe <Unit> .None().FlatMapUnit(() => Maybe <int> .Some(3)); 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); }
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_ReturningAsyncNone_UsingNoArgs_WhenSome_ReturnsNone() { var source = await AsyncMaybe <Unit> .Some(new Unit()).FlatMapUnitAsync(() => Task.FromResult(AsyncMaybe <int> .None())); source.MustBeNone(); }
public async Task Async_OnNone_WithFunction_ThrowsException() { var source = AsyncMaybe <int> .None(); await Assert.ThrowsAsync <ExpectedException>(() => source.OrThrow(() => new ExpectedException())); }
public async Task None() { var source = await AsyncMaybe <int> .None(); source.MustBeNone(); }