public void ResolvedWithDefaultErr_ForwardErrThroughTheChain()
{
string errorMessage = "Forwarded Err";
Resolved resolved = Resolved.ErrAsIEnumerable(new Exception(errorMessage));
var result = resolved
.Match(
Ok: () => Resolved.Ok(),
Err: Behavior.Forward
)
.Match(
Ok: () => Resolved.Ok(),
Err: Behavior.Forward
)
.Match <int>(
Ok: () => Resolved.Ok(1),
Err: Behavior.Forward
);
Assert.AreEqual(typeof(Err), result.Value.GetType());
var err = (Err)result.Value;
Assert.AreEqual(err.Value.First().Message, errorMessage);
}
public void ResolvedWithOkTypeAndErrType_UnwrapValue()
{
Resolved <bool, string> resolved = Resolved.Ok(true);
var value = resolved.Unwrap();
Assert.IsTrue(value);
}
public void DifferentTypeChainedResolvedErr_ResolvedValueIsString()
{
IEnumerable <Exception> errors = new Exception[0];
Resolved resolved = Resolved.Err(errors);
var r = resolved
.Match <Resolved <bool> >(
Ok: () => Resolved.Ok(true),
Err: (err) => Resolved.Err(err)
)
.Match <Resolved <int, string> >(
Ok: (b) => Resolved.Ok(1),
Err: (err) => Resolved.Err("Erro")
);
Assert.IsTrue(r.IsErr);
r.Match(
Ok: (n) => { Assert.Fail("Unexpected error occurred"); },
Err: (err) =>
{
Assert.AreEqual(typeof(string), err.GetType());
Assert.AreEqual("Erro", err);
}
);
}
public void ResolvedWithStringErr_ForwardErrThroughTheChain()
{
string errorMessage = "Forwarded Err";
Resolved <string, string> resolved = Resolved.Err(errorMessage);
var result = resolved
.Match <int>(
Ok: (innerValue) => Resolved.Ok(1),
Err: Behavior.Forward
)
.Match <bool>(
Ok: (innerValue) => Resolved.Ok(true),
Err: Behavior.Forward
)
.Match <char>(
Ok: (innerValue) => Resolved.Ok('\a'),
Err: Behavior.Forward
)
.Match(
Ok: (innerValue) => Resolved.Ok('\b'),
Err: Behavior.Forward
);
Assert.AreEqual(typeof(Err <string>), result.Value.GetType());
var err = (Err <string>)result.Value;
Assert.AreEqual(err.Value, errorMessage);
}
public void DifferentTypeChainedResolvedOk_ResolvedValueIsTrue()
{
Resolved resolved = Resolved.Ok();
var r = resolved
.Match <Resolved <int> >(
Ok: () => Resolved.Ok(1),
Err: (err) => Resolved.Err(err)
)
.Match <Resolved>(
Ok: (n) => Resolved.Ok(),
Err: (err) => Resolved.Err(err)
)
.Match <Resolved <bool> >(
Ok: () => Resolved.Ok(true),
Err: (err) => Resolved.Err(err)
);
Assert.IsTrue(r.IsOk);
r.Match(
Ok: (value) => { Assert.IsTrue(value); },
Err: (err) => { Assert.Fail("Unexpected error occurred"); }
);
}
public void ResolvedWithIntegerOk_UnwrapValue()
{
Resolved <int> resolved = Resolved.Ok(5);
var value = resolved.Unwrap();
Assert.AreEqual(5, value);
}
public void SameTypeChainedResolvedOk_ReturnsLastNumberInTheChain()
{
Resolved <int> resolved = Resolved.Ok(0);
var r = resolved
.Match <Resolved <int> >(
Ok: (n) => Resolved.Ok(1),
Err: (err) => Resolved.Err(err)
)
.Match <Resolved <int> >(
Ok: (n) => Resolved.Ok(2),
Err: (err) => Resolved.Err(err)
)
.Match <Resolved <int> >(
Ok: (n) => Resolved.Ok(3),
Err: (err) => Resolved.Err(err)
);
Assert.IsTrue(r.IsOk);
r.Match(
Ok: (n) => { Assert.AreEqual(3, n); },
Err: (err) => { Assert.Fail("Unexpected error occurred"); }
);
}
public void NestedResolved_ReturnsResolvedOkWithIntValue()
{
Resolved <int> innerResolved = Resolved.Ok(1);
Resolved <Resolved <int> > resolved = Resolved.Ok(innerResolved);
var result = resolved.Match <Resolved <int> >(
Ok: (r) =>
{
var number = r.Match(
Ok: (n) => 1,
Err: (err) => 0
);
return(Resolved.Ok(number));
},
Err: (err) => Resolved.Err(err)
);
Assert.IsTrue(result.IsOk);
result.Match(
Ok: (n) => Assert.AreEqual(1, n),
Err: (err) => Assert.Fail("Unexpected error occurred")
);
}
public void ResolvedWithIntegerOk_ReturnsBoolValueTrue()
{
Resolved <int, string> resolved = Resolved.Ok(1);
var result = resolved.Match(
Ok: (n) => true,
Err: (e) => false
);
Assert.IsTrue(result);
}
public void ResolvedWithEmptyOk_MatchOkAndReturnsEmptyOk()
{
Resolved resolved = Resolved.Ok();
var r = resolved.Match <Resolved>(
Ok: () => Resolved.Ok(),
Err: (err) => Resolved.Err(err)
);
Assert.IsTrue(r.IsOk);
Assert.AreEqual(r.Value.GetType(), typeof(Ok));
}
public void ResolvedWithEmptyOk_MatchOkAndReturnsOkWithIntegerValue()
{
Resolved resolved = Resolved.Ok();
var r = resolved.Match <Resolved <int> >(
Ok: () => Resolved.Ok(10),
Err: (err) => Resolved.Err(err)
);
Assert.IsTrue(r.IsOk);
Assert.AreEqual(r.Value.GetType(), typeof(Ok <int>));
Assert.AreEqual(10, ((Ok <int>)r.Value).Value);
}
public void SameTypeChainedResolvedErr_ReturnsLastNumberInTheChain()
{
IEnumerable <Exception> errors = new[] { new Exception(), new Exception() };
Resolved resolved = Resolved.Err(errors);
var r = resolved
.Match <Resolved>(
Ok: () => Resolved.Ok(),
Err: (err) => Resolved.Err(new Exception[] { new Exception(), new Exception() } as IEnumerable <Exception>)
)
.Match <Resolved>(
Ok: () => Resolved.Ok(),
Err: (err) => Resolved.Err(new Exception[] { new Exception() } as IEnumerable <Exception>)
);
Assert.IsTrue(r.IsErr);
r.Match(
Ok: () => { Assert.Fail("Unexpected error occurred"); },
Err: (err) => { Assert.AreEqual(1, err.Count()); }
);
}
public void ResolvedWithIntegerOk_IsErrEqualsFalse()
{
Resolved <int> resolved = Resolved.Ok(15);
Assert.IsFalse(resolved.IsErr);
}
public void ResolvedWithEmptyOk_IsErrEqualsFalse()
{
Resolved resolved = Resolved.Ok();
Assert.IsFalse(resolved.IsErr);
}
public void ResolvedWithIntegerOk_IsOkEqualsTrue()
{
Resolved <int> resolved = Resolved.Ok(15);
Assert.IsTrue(resolved.IsOk);
}
public void ResolvedWithEmptyOk_IsOkEqualsTrue()
{
Resolved resolved = Resolved.Ok();
Assert.IsTrue(resolved.IsOk);
}
