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