public void ConstructFailure_ErrorNotNull()
{
var testValue = EFailable <object> .Failure(new ArgumentException());
Assert.That(testValue.IsSuccess, Is.False);
Assert.That(testValue.IsFailure, Is.True);
}
public void Equals_Option()
{
var aEOption = EOption <int> .Some(4);
var aOption = Option <int, Exception> .Some(4);
var bEOption = EOption <int> .None;
var bOption = Option <int, Exception> .None;
var exception = new ArgumentException();
var cEOption = EFailable <int> .Failure(exception);
var cOption = Failable <int, Exception> .Failure(exception);
Assert.That(aEOption.GetHashCode(), Is.EqualTo(aOption.GetHashCode()), "HashCode not correct (Success-Case)");
Assert.That(bEOption.GetHashCode(), Is.EqualTo(bOption.GetHashCode()), "HashCode not correct (None-Case)");
Assert.That(cEOption.GetHashCode(), Is.EqualTo(cOption.GetHashCode()), "HashCode not correct (Failure-Case)");
Assert.That(aEOption, Is.EqualTo(aOption), "EOption-Equals is buggy! (Some-Case)");
Assert.That(bEOption, Is.EqualTo(bOption), "EOption-Equals is buggy! (None-Case)");
Assert.That(cEOption, Is.EqualTo(cOption), "EOption-Equals is buggy! (Failure-Case)");
Assert.That(aOption, Is.EqualTo(aEOption), "Implementation of Option is not accepting EOption! (Some-Case)");
Assert.That(bOption, Is.EqualTo(bEOption), "Implementation of Option is not accepting EOption! (None-Case)");
Assert.That(cOption, Is.EqualTo(cEOption), "Implementation of Option is not accepting EOption! (Failure-Case)");
Assert.That(aEOption, Is.Not.EqualTo(bOption)); //sanity-checks
Assert.That(cOption, Is.Not.EqualTo(bEOption));
}
public void Equals_FailedEqualObjects()
{
var x = EFailable <int> .Failure(new ArgumentException());
var y = EFailable <int> .Failure(new ArgumentException());
Assert.That(x.Equals(y), Is.False);
}
public void ConvertToEOption_Failure()
{
var EFailable = EFailable <string> .Failure(new ArgumentException( "abc" ));
EOption <string> EOption = EFailable.ToEOption();
Assert.That(EOption.IsFailure, Is.True);
}
public void Equals_FailedInequal()
{
var x = EFailable <object> .Failure(new ArgumentException("what a disappointment"));
var y = EFailable <object> .Failure(new ArgumentException("yet another disappointment"));
Assert.That(x.Equals(y), Is.False);
}
public void Map_NestingInMap()
{
var flag = EFailable <bool> .Success(true);
var result = flag.Map(_ => EFailable <bool> .Success(true));
Assert.That(result.Or(EFailable <bool> .Failure(new ArgumentException())).Or(false), Is.True);
}
public void ConvertToMaybe_Failure()
{
var EFailable = EFailable <string> .Failure(new ArgumentException());
var maybe = EFailable.ToMaybe();
Assert.That(maybe.IsNone, Is.True);
}
public void TryGet_Value_Failure()
{
var EFailable = EFailable <string> .Failure(new ArgumentException());
EFailable.TryGetValue(out var s);
Assert.IsNull(s);
}
public void ConvertFailable_Failure()
{
var EFailable = EFailable <string> .Failure(new ArgumentException( "abc" ));
Failable <string, Exception> failable = EFailable.ToFailable();
Assert.That(failable.IsFailure, Is.True);
}
public void Equals_DifferentTypeInequalForFailure()
{
var x = EFailable <int> .Failure(new ArgumentException("horrible"));
var y = EFailable <object> .Failure(new ArgumentException("horrible"));
Assert.That(x.Equals(y), Is.False);
}
public void Map_Failure()
{
var e = new ArgumentException();
var original = EFailable <string> .Failure(e);
var result = original.Map(s => s += " welt");
Assert.That(result.FailureOrThrow, Is.EqualTo(e));
}
public void Equals_FailedSameInstance()
{
var e = new ArgumentException();
var x = EFailable <int> .Failure(e);
var y = EFailable <int> .Failure(e);
Assert.That(x.Equals(y), Is.True);
}
public void OrWithParallelType_Failure()
{
var myOtherSubclass = new MyOtherSubclass();
var underTest = EFailable <MyClass> .Failure(new ArgumentException( "irrelevant" ));
var actualValue = underTest.Or(myOtherSubclass);
Assert.That(actualValue, Is.SameAs(myOtherSubclass));
}
public void Equals_FailedInequalToSuccess()
{
var x = EFailable <int> .Failure(new ArgumentException("how appaling!"));
var y = EFailable <int> .Success(0);
var z = EFailable <EFailable <int> > .Success(y);
Assert.That(x.Equals(y), Is.False);
Assert.That(x.Equals(z), Is.False);
}
public void Flatten_Some()
{
var a = EFailable <string> .Success("hallo");
var b = EFailable <EFailable <string> > .Success(EFailable <string> .Success("hallo"));
var c = EFailable <EFailable <string> > .Success(EFailable <string> .Failure(new Exception("")));
Assert.That(b, Is.Not.EqualTo(a));
Assert.That(b.Flatten(), Is.EqualTo(a));
Assert.That(b.Flatten(), Is.Not.EqualTo(c));
}
public void Flatten_Failure()
{
var a = EFailable <string> .Failure(new Exception( "" ));
var b = EFailable <EFailable <string> > .Success(a); //use same instance so that Exception.Equals() returns true
var c = EFailable <EFailable <string> > .Success(EFailable <string> .Success("whatever"));
Assert.That(b, Is.Not.EqualTo(a));
Assert.That(b.Flatten(), Is.EqualTo(a));
Assert.That(b.Flatten(), Is.Not.EqualTo(c));
}
public void Equals_Failable_DifferentType()
{
var aEFail = EFailable <int> .Success(4);
var aFail = Failable <int, string> .Success(4);
var exception = new ArgumentException();
var bEFail = EFailable <int> .Failure(exception);
var bFail = Failable <int, string> .Failure("whatever");
Assert.That(aEFail, Is.Not.EqualTo(aFail));
Assert.That(bEFail, Is.Not.EqualTo(bFail));
Assert.That(aFail, Is.Not.EqualTo(aEFail));
Assert.That(bFail, Is.Not.EqualTo(bEFail));
}
public void Nesting()
{
var successInnerSuccess = EFailable <EFailable <int> > .Success(EFailable <int> .Success(123));
var successInnerFail = EFailable <EFailable <int> > .Success(EFailable <int> .Failure(new ArgumentException()));
var failureInnerSuccess = EFailable <EFailable <int> > .Failure(new ArgumentException());
var failureInnerFail = EFailable <EFailable <int> > .Failure(new ArgumentException());
Assert.That(successInnerSuccess.IsSuccess, Is.True);
Assert.That(successInnerFail.IsSuccess, Is.True);
Assert.That(successInnerSuccess.OrThrow().IsSuccess, Is.True);
Assert.That(successInnerFail.OrThrow().IsSuccess, Is.False);
Assert.That(failureInnerSuccess.IsSuccess, Is.False);
Assert.That(failureInnerFail.IsSuccess, Is.False);
}
public void Equals_Failable()
{
var aEFail = EFailable <int> .Success(4);
var aFail = Failable <int, Exception> .Success(4);
var exception = new ArgumentException();
var bEFail = EFailable <int> .Failure(exception);
var bFail = Failable <int, Exception> .Failure(exception);
Assert.That(aEFail.GetHashCode(), Is.EqualTo(aFail.GetHashCode()), "HashCode not correct (Success-Case)");
Assert.That(bEFail.GetHashCode(), Is.EqualTo(bFail.GetHashCode()), "HashCode not correct (Failure-Case)");
Assert.That(aEFail, Is.EqualTo(aFail), "EFailable-Equals is buggy! (Success-Case)");
Assert.That(bEFail, Is.EqualTo(bFail), "EFailable-Equals is buggy! (Failure-Case)");
Assert.That(aFail, Is.EqualTo(aEFail), "Implementation of Failable is not accepting EFailable! (Success-Case)");
Assert.That(bFail, Is.EqualTo(bEFail), "Implementation of Failable is not accepting EFailable! (Failure-Case)");
Assert.That(aEFail, Is.Not.EqualTo(bFail)); //sanity-check
}
public void Equals_Option_DifferentType()
{
var aEOption = EOption <int> .Some(4);
var aOption = Option <int, string> .Some(4);
var bEOption = EOption <int> .None;
var bOption = Option <int, string> .None;
var exception = new ArgumentException();
var cEOption = EFailable <int> .Failure(exception);
var cOption = Failable <int, string> .Failure("whatever");
Assert.That(aEOption, Is.Not.EqualTo(aOption));
Assert.That(bEOption, Is.Not.EqualTo(bOption));
Assert.That(cEOption, Is.Not.EqualTo(cOption));
Assert.That(aOption, Is.Not.EqualTo(aEOption));
Assert.That(bOption, Is.Not.EqualTo(bEOption));
Assert.That(cOption, Is.Not.EqualTo(cEOption));
}
public void ConstructFailure_ErrorNull()
{
Assert.That(() => EFailable <object> .Failure(null), Throws.TypeOf <FailableFailureConstructionException>());
}
public void Or_FailureOrNull()
{
Assert.That(EFailable <object> .Failure(new ArgumentException()).Or(null), Is.Null);
}
public void TryGet_Result_Failure()
{
var EFailable = EFailable <string> .Failure(new ArgumentException());
Assert.IsFalse(EFailable.TryGetValue(out var s));
}
public void Is_PredicateUndefined()
{
var EFailable = EFailable <string> .Failure(new ArgumentException());
Assert.That(EFailable.Holds(s => s.Equals("hubba-hub")), Is.EqualTo(false));
}
public void Is_FalseWhenNone()
{
var f = EFailable <string> .Failure(new ArgumentException());
Assert.That(f.Is("hubba"), Is.EqualTo(false));
}
public void Or_FailureOrValue()
{
Assert.That(EFailable <int> .Failure(new ArgumentException()).Or(1), Is.EqualTo(1));
}
public void Error_ReturnsFailure()
{
var expected = new ArgumentNullException();
Assert.That(EFailable <string> .Failure(expected).FailureOrThrow(), Is.EqualTo(expected));
}
public void ToString_Failure()
{
Assert.That(EFailable <TestObj> .Failure(new ArgumentException("evil")).ToString(), Is.EqualTo("[EFailable<TestObj>.Failure: System.ArgumentException: evil]"));
}
public void OrThrow_ThrowsNotInnerExceptionIfFailure()
{
Assert.Throws <FailableFailureException>(() => EFailable <string> .Failure(new ArgumentOutOfRangeException()).OrThrow());
}
