public static void Equality3() { var ok = Outcome.Ok; var nok = Outcome.FromError("error"); Assert.True(nok != ok); }
public static void ToValue1() { var message = "error"; var err = Outcome <Obj> .FromError(message); Assert.Throws <InvalidCastException>(() => err.ToValue()); }
public static void GetHashCode2() { var nok1 = Outcome.FromError("error"); var nok2 = Outcome.FromError("error"); Assert.Equal(nok1.GetHashCode(), nok2.GetHashCode()); }
public static void FromError1() { var nok = Outcome <int> .FromError("error"); Assert.True(nok.IsError); Assert.False(nok.IsSuccess); }
public static void ToMaybe2() { var nok = Outcome <Obj> .FromError("error"); var maybe = nok.ToMaybe(); Assert.True(maybe.IsNone); }
public static void Deconstruct2() { var nok = Outcome.FromError("error"); var(succeed, err) = nok; Assert.False(succeed); Assert.Equal("error", err); }
public static void ValueOrThrow2() { var nok = Outcome <Obj> .FromError("error"); Action act = () => nok.ValueOrThrow(); Assert.Throws <InvalidOperationException>(act); }
public static void ValueOrNone() { var nok = Outcome <Obj> .FromError("error"); var maybe = nok.ValueOrNone(); Assert.True(maybe.IsNone); }
public static void ValueOrElse2() { var nok = Outcome <Obj> .FromError("error"); var exp = new Obj(); Assert.Same(exp, nok.ValueOrElse(exp)); Assert.Same(exp, nok.ValueOrElse(() => exp)); }
public Outcome <TResult> ZipWith <TSecond, TResult>( Outcome <TSecond> second, Func <T, TSecond, TResult> zipper) { Require.NotNull(zipper, nameof(zipper)); return(IsError && second.IsError ? Outcome <TResult> .FromError(Error) : Outcome <TResult> .η(zipper(Value, second.Value))); }
public static void Equals1() { var ok = Outcome.Ok; Assert.True(ok.Equals(ok)); var nok = Outcome.FromError("error"); Assert.True(nok.Equals(nok)); }
public static void GetHashCode1() { var nok = Outcome.FromError("error"); Assert.Equal(nok.GetHashCode(), nok.GetHashCode()); var ok = Outcome.Ok; Assert.Equal(ok.GetHashCode(), ok.GetHashCode()); }
public static void Deconstruct2() { var exp = "error"; var nok = Outcome <Obj> .FromError(exp); var(succeed, value, err) = nok; Assert.False(succeed); Assert.Equal(exp, err); Assert.Null(value); }
public static void ValueOrThrow0() { var ok = Outcome.Of(new Obj()); Assert.Throws <ArgumentNullException>("exceptionFactory", () => ok.ValueOrThrow(null)); var nok = Outcome <Obj> .FromError("error"); Assert.Throws <ArgumentNullException>("exceptionFactory", () => nok.ValueOrThrow(null)); }
public static void Equals2() { var ok = Outcome.Ok; Assert.False(ok.Equals(null)); var nok = Outcome.FromError("error"); Assert.False(nok.Equals(null)); }
public static void GetHashCode3() { var nok1 = Outcome.FromError("error1"); var nok2 = Outcome.FromError("error2"); Assert.NotEqual(nok1.GetHashCode(), nok2.GetHashCode()); var ok = Outcome.Ok; Assert.NotEqual(nok1.GetHashCode(), ok.GetHashCode()); }
public static void ToString1() { var ok = Outcome.Ok; Assert.Equal("Success", ok.ToString()); var error = "My error"; var nok = Outcome.FromError(error); Assert.Contains(error, nok.ToString(), StringComparison.OrdinalIgnoreCase); }
public static void Equals4() { var ok = Outcome.Ok; var nok = Outcome.FromError("error"); var nok1 = Outcome.FromError("error1"); var nok2 = Outcome.FromError("error1"); Assert.False(ok.Equals(nok)); Assert.False(nok1.Equals(nok)); Assert.True(nok1.Equals(nok2)); }
public static void ToString1() { var value = new Obj("My value"); var ok = Outcome.Of(value); Assert.Contains(value.ToString(), ok.ToString(), StringComparison.OrdinalIgnoreCase); var error = "My error"; var nok = Outcome <Obj> .FromError(error); Assert.Contains(error, nok.ToString(), StringComparison.OrdinalIgnoreCase); }
public static void ValueOrThrow3() { var message = "error"; var nok = Outcome <Obj> .FromError(message); Action act = () => nok.ValueOrThrow(err => new SimpleException(err)); var ex = Record.Exception(act); Assert.NotNull(ex); Assert.IsType <SimpleException>(ex); Assert.Equal(message, ex.Message); }
public static void Equality1() { var nok1 = Outcome.FromError("error"); var nok2 = Outcome.FromError("error"); Assert.True(nok1 == nok2); Assert.False(nok1 != nok2); var nok3 = Outcome.FromError("error1"); var nok4 = Outcome.FromError("error2"); Assert.False(nok3 == nok4); Assert.True(nok3 != nok4); }
public static void GetHashCode2() { var nok1 = Outcome <Obj> .FromError("error"); var nok2 = Outcome <Obj> .FromError("error"); Assert.Equal(nok1.GetHashCode(), nok2.GetHashCode()); Assert.Equal(nok1.GetHashCode(EqualityComparer <Obj> .Default), nok2.GetHashCode(EqualityComparer <Obj> .Default)); var ok1 = Outcome.Of(Tuple.Create("1")); var ok2 = Outcome.Of(Tuple.Create("1")); Assert.Equal(ok1.GetHashCode(), ok2.GetHashCode()); Assert.Equal(ok1.GetHashCode(EqualityComparer <Tuple <string> > .Default), ok2.GetHashCode(EqualityComparer <Tuple <string> > .Default)); }
public static void GetHashCode1() { var nok = Outcome <Obj> .FromError("error"); Assert.Equal(nok.GetHashCode(), nok.GetHashCode()); Assert.Equal(nok.GetHashCode(EqualityComparer <Obj> .Default), nok.GetHashCode(EqualityComparer <Obj> .Default)); var ok1 = Outcome.Of(new Obj()); Assert.Equal(ok1.GetHashCode(), ok1.GetHashCode()); Assert.Equal(ok1.GetHashCode(EqualityComparer <Obj> .Default), ok1.GetHashCode(EqualityComparer <Obj> .Default)); var ok2 = Outcome.Of(1); Assert.Equal(ok2.GetHashCode(), ok2.GetHashCode()); Assert.Equal(ok2.GetHashCode(EqualityComparer <int> .Default), ok2.GetHashCode(EqualityComparer <int> .Default)); }
public static void GetHashCode3() { var nok1 = Outcome <int> .FromError("error1"); var nok2 = Outcome <int> .FromError("error2"); Assert.NotEqual(nok1.GetHashCode(), nok2.GetHashCode()); Assert.NotEqual(nok1.GetHashCode(EqualityComparer <int> .Default), nok2.GetHashCode(EqualityComparer <int> .Default)); var ok1 = Outcome.Of(1); var ok2 = Outcome.Of(2); Assert.NotEqual(ok1.GetHashCode(), ok2.GetHashCode()); Assert.NotEqual(ok1.GetHashCode(EqualityComparer <int> .Default), ok2.GetHashCode(EqualityComparer <int> .Default)); Assert.NotEqual(ok1.GetHashCode(), nok1.GetHashCode()); Assert.NotEqual(ok1.GetHashCode(EqualityComparer <int> .Default), nok1.GetHashCode(EqualityComparer <int> .Default)); }
public Outcome <TResult> SelectMany <TMiddle, TResult>( Func <T, Outcome <TMiddle> > selector, Func <T, TMiddle, TResult> resultSelector) { Require.NotNull(selector, nameof(selector)); Require.NotNull(resultSelector, nameof(resultSelector)); if (IsError) { return(Outcome <TResult> .FromError(Error)); } var middle = selector(Value); if (middle.IsError) { return(Outcome <TResult> .FromError(Error)); } return(Outcome <TResult> .η(resultSelector(Value, middle.Value))); }
public static void ValueOrDefault2() { var nok = Outcome <Obj> .FromError("error"); Assert.Same(default(Obj), nok.ValueOrDefault()); }
public Outcome <Unit> Skip() => IsError ? Outcome <Unit> .FromError(Error) : Outcome.Unit;
public static void FromError0() { Assert.Throws <ArgumentNullException>("error", () => Outcome <int> .FromError(null)); Assert.Throws <ArgumentException>("error", () => Outcome <int> .FromError(String.Empty)); }
public Outcome <TResult> Select <TResult>(Func <T, TResult> selector) { Require.NotNull(selector, nameof(selector)); return(IsError ? Outcome <TResult> .FromError(Error) : Outcome <TResult> .η(selector(Value))); }
public Outcome <TResult> Gather <TResult>(Outcome <Func <T, TResult> > applicative) => IsError && applicative.IsError ? Outcome <TResult> .FromError(Error) : Outcome <TResult> .η(applicative.Value(Value));