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); }