public void ValueCustomResultToEither()
{
Result <int, CustomErrorTest> resultOk = Result.Ok <int, CustomErrorTest>(42);
Either <CustomErrorTest, int> eitherErrorInt = resultOk.ToEither();
CheckRightEither(eitherErrorInt, 42);
Result <int, CustomErrorTest> resultWarn = Result.Warn <int, CustomErrorTest>(12, "Warning");
eitherErrorInt = resultWarn.ToEither();
CheckRightEither(eitherErrorInt, 12);
Result <Person, CustomErrorTest> resultPersonOk = Result.Ok <Person, CustomErrorTest>(null);
Assert.Throws <InvalidOperationException>(() => resultPersonOk.ToEither());
Result <Person, CustomErrorTest> resultPersonWarn = Result.Warn <Person, CustomErrorTest>(null, "Warning");
Assert.Throws <InvalidOperationException>(() => resultPersonWarn.ToEither());
var customErrorObject = new CustomErrorTest();
Result <int, CustomErrorTest> resultFail = Result.Fail <int, CustomErrorTest>("Failure", customErrorObject);
eitherErrorInt = resultFail.ToEither();
CheckLeftEither(eitherErrorInt, customErrorObject);
}
public void CastValueCustomResultTInToValueCustomResultTOutWithAs()
{
var testObject = new TestClass();
var testObjectLeaf = new TestClassLeaf();
var customErrorObject = new CustomErrorTest {
ErrorCode = -4
};
// Result ok
var ok = Result.Ok <TestClass, CustomErrorTest>(testObjectLeaf);
var result = ok.Cast <TestClassLeaf>();
CheckResultOk(result, testObjectLeaf);
ok = Result.Ok <TestClass, CustomErrorTest>(testObject);
result = ok.Cast <TestClassLeaf>();
CheckResultOk(result, null);
// Result warn
var warning = Result.Warn <TestClass, CustomErrorTest>(testObjectLeaf, "My warning");
result = warning.Cast <TestClassLeaf>();
CheckResultWarn(result, testObjectLeaf, "My warning");
warning = Result.Warn <TestClass, CustomErrorTest>(testObject, "My warning");
result = warning.Cast <TestClassLeaf>();
CheckResultWarn(result, null, "My warning");
// Result fail
var failure = Result.Fail <TestClass, CustomErrorTest>("My failure", customErrorObject);
result = failure.Cast <TestClassLeaf>();
CheckResultFail(result, "My failure", customErrorObject);
}
public void CustomResultOnAnyToCustomResult()
{
#region Local function
void CheckOnAny(CustomResult <CustomErrorTest> result)
{
int counter = 0;
CustomResult <CustomErrorTest> res = result.OnAny(() => { ++counter; });
Assert.AreEqual(1, counter);
Assert.AreEqual(result, res);
}
#endregion
// Ok result
var ok = Result.CustomOk <CustomErrorTest>();
CheckOnAny(ok);
// Warning result
var warning = Result.CustomWarn <CustomErrorTest>("My warning");
CheckOnAny(warning);
// Failure result
var customErrorObject = new CustomErrorTest {
ErrorCode = -8
};
var failure = Result.CustomFail("My failure", customErrorObject);
CheckOnAny(failure);
Assert.Throws <ArgumentNullException>(() => ok.OnAny((Action)null));
}
public void ValueCustomResultOnFailureToValueCustomResult()
{
#region Local function
void CheckOnFailure(Result <int, CustomErrorTest> result, bool treatWarningAsError, bool expectFailure)
{
int counterFailure = 0;
Result <int, CustomErrorTest> res = result.OnFailure(() => ++ counterFailure, treatWarningAsError);
Assert.AreEqual(expectFailure ? 1 : 0, counterFailure);
Assert.AreEqual(result, res);
}
#endregion
// Ok result
var ok = Result.Ok <int, CustomErrorTest>(24);
CheckOnFailure(ok, false, false);
CheckOnFailure(ok, true, false);
// Warning result
var warning = Result.Warn <int, CustomErrorTest>(14, "My warning");
CheckOnFailure(warning, false, false);
CheckOnFailure(warning, true, true);
// Failure result
var customErrorObject = new CustomErrorTest {
ErrorCode = -2
};
var failure = Result.Fail <int, CustomErrorTest>("My failure", customErrorObject);
CheckOnFailure(failure, false, true);
CheckOnFailure(failure, true, true);
Assert.Throws <ArgumentNullException>(() => ok.OnFailure((Action)null));
}
public void ValueCustomResultOnAnyToValueCustomResultWithParam()
{
#region Local function
void CheckOnAny(Result <int, CustomErrorTest> result)
{
int counter = 0;
Result <int, CustomErrorTest> res = result.OnAny(r => { ++counter; });
Assert.AreEqual(1, counter);
Assert.AreEqual(result, res);
}
#endregion
// Ok result
var ok = Result.Ok <int, CustomErrorTest>(14);
CheckOnAny(ok);
// Warning result
var warning = Result.Warn <int, CustomErrorTest>(78, "My warning");
CheckOnAny(warning);
// Failure result
var customErrorObject = new CustomErrorTest {
ErrorCode = -1
};
var failure = Result.Fail <int, CustomErrorTest>("My failure", customErrorObject);
CheckOnAny(failure);
Assert.Throws <ArgumentNullException>(() => ok.OnAny((Action <Result <int, CustomErrorTest> >)null));
}
public void ResultValueTErrorToCustomResultImplicitConstruction()
{
// Ok result
var ok = Result.Ok <int, CustomErrorTest>(42);
CustomResult <CustomErrorTest> customResultOk = ok;
CheckResultOk(customResultOk);
// Warning result
var warning = Result.Warn <int, CustomErrorTest>(42, "My warning");
CustomResult <CustomErrorTest> customResultWarning = warning;
CheckResultWarn(customResultWarning, "My warning");
var warnException = new Exception("Warning Exception");
warning = Result.Warn <int, CustomErrorTest>(42, "My warning", warnException);
customResultWarning = warning;
CheckResultWarn(customResultWarning, "My warning", warnException);
// Failure result
var customErrorObject = new CustomErrorTest {
ErrorCode = -12
};
var failure = Result.Fail <int, CustomErrorTest>("My failure", customErrorObject);
CustomResult <CustomErrorTest> customResultFailure = failure;
CheckResultFail(customResultFailure, "My failure", customErrorObject);
var failException = new Exception("Failure Exception");
failure = Result.Fail <int, CustomErrorTest>("My failure", customErrorObject, failException);
customResultFailure = failure;
CheckResultFail(customResultFailure, "My failure", customErrorObject, failException);
}
public void CastResultToCustomResult()
{
var customErrorObjectFactory = new CustomErrorTest {
ErrorCode = -8
};
int counterErrorFactory = 0;
// Result ok
var ok = Result.Ok();
var customResult = ok.CustomCast(customErrorObjectFactory);
CheckResultOk(customResult);
customResult = ok.CustomCast(
() =>
{
++counterErrorFactory;
return(customErrorObjectFactory);
});
Assert.AreEqual(0, counterErrorFactory);
CheckResultOk(customResult);
// Result warn
var warning = Result.Warn("My warning");
customResult = warning.CustomCast(customErrorObjectFactory);
CheckResultWarn(customResult, "My warning");
customResult = warning.CustomCast(
() =>
{
++counterErrorFactory;
return(customErrorObjectFactory);
});
Assert.AreEqual(0, counterErrorFactory);
CheckResultWarn(customResult, "My warning");
// Result fail
var failure = Result.Fail("My failure");
customResult = failure.CustomCast(customErrorObjectFactory);
CheckResultFail(customResult, "My failure", customErrorObjectFactory);
customResult = failure.CustomCast(
() =>
{
++counterErrorFactory;
return(customErrorObjectFactory);
});
Assert.AreEqual(1, counterErrorFactory);
CheckResultFail(customResult, "My failure", customErrorObjectFactory);
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
Assert.Throws <ArgumentNullException>(() => ok.CustomCast((CustomErrorTest)null));
Assert.Throws <ArgumentNullException>(() => ok.CustomCast((Func <CustomErrorTest>)null));
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
}
public void ResultLogicErrorCompare()
{
var customErrorObject = new CustomErrorTest {
ErrorCode = -1
};
// Results
var logicOk1 = new ResultLogic <CustomErrorTest>();
var logicOk2 = new ResultLogic <CustomErrorTest>();
var logicWarn1 = new ResultLogic <CustomErrorTest>(true, "My warning", null, null);
var logicWarn2 = new ResultLogic <CustomErrorTest>(true, "My warning", null, null);
var logicWarn3 = new ResultLogic <CustomErrorTest>(true, "My warning 2", null, null);
var logicFail1 = new ResultLogic <CustomErrorTest>(false, "My failure", customErrorObject, null);
var logicFail2 = new ResultLogic <CustomErrorTest>(false, "My failure", customErrorObject, null);
var logicFail3 = new ResultLogic <CustomErrorTest>(false, "My failure 2", customErrorObject, null);
Assert.IsFalse(logicOk1 < logicOk2);
Assert.IsTrue(logicOk1 <= logicOk2);
Assert.IsFalse(logicOk1 > logicOk2);
Assert.IsTrue(logicOk1 >= logicOk2);
Assert.IsFalse(logicOk1 < logicWarn1);
Assert.IsFalse(logicOk1 <= logicWarn1);
Assert.IsTrue(logicOk1 > logicWarn1);
Assert.IsTrue(logicOk1 >= logicWarn1);
Assert.IsFalse(logicOk1 < logicFail1);
Assert.IsFalse(logicOk1 <= logicFail1);
Assert.IsTrue(logicOk1 > logicFail1);
Assert.IsTrue(logicOk1 >= logicFail1);
Assert.IsFalse(logicWarn1 < logicWarn2);
Assert.IsTrue(logicWarn1 <= logicWarn2);
Assert.IsFalse(logicWarn1 > logicWarn2);
Assert.IsTrue(logicWarn1 >= logicWarn2);
Assert.IsFalse(logicWarn1 < logicWarn3);
Assert.IsTrue(logicWarn1 <= logicWarn3);
Assert.IsFalse(logicWarn1 > logicWarn3);
Assert.IsTrue(logicWarn1 >= logicWarn3);
Assert.IsFalse(logicWarn1 < logicFail1);
Assert.IsFalse(logicWarn1 <= logicFail1);
Assert.IsTrue(logicWarn1 > logicFail1);
Assert.IsTrue(logicWarn1 >= logicFail1);
Assert.IsFalse(logicFail1 < logicFail2);
Assert.IsTrue(logicFail1 <= logicFail2);
Assert.IsFalse(logicFail1 > logicFail2);
Assert.IsTrue(logicFail1 >= logicFail2);
Assert.IsFalse(logicFail1 < logicFail3);
Assert.IsTrue(logicFail1 <= logicFail3);
Assert.IsFalse(logicFail1 > logicFail3);
Assert.IsTrue(logicFail1 >= logicFail3);
}
public void CastCustomResultToValueCustomResult()
{
var customErrorObject = new CustomErrorTest {
ErrorCode = -5
};
int counterValueFactory = 0;
// Result ok
var ok = Result.CustomOk <CustomErrorTest>();
var result = ok.CustomCast(22);
CheckResultOk(result, 22);
result = ok.CustomCast(
() =>
{
++counterValueFactory;
return(33);
});
Assert.AreEqual(1, counterValueFactory);
CheckResultOk(result, 33);
// Result warn
var warning = Result.CustomWarn <CustomErrorTest>("My warning");
result = warning.CustomCast(22);
CheckResultWarn(result, 22, "My warning");
result = warning.CustomCast(
() =>
{
++counterValueFactory;
return(33);
});
Assert.AreEqual(2, counterValueFactory);
CheckResultWarn(result, 33, "My warning");
// Result fail
var failure = Result.CustomFail("My failure", customErrorObject);
result = failure.CustomCast(22);
CheckResultFail(result, "My failure", customErrorObject);
result = failure.CustomCast(
() =>
{
++counterValueFactory;
return(33);
});
Assert.AreEqual(2, counterValueFactory);
CheckResultFail(result, "My failure", customErrorObject);
Assert.Throws <ArgumentNullException>(() => ok.CustomCast((Func <float>)null));
}
public void ValueCustomResultOnAnyTOut()
{
#region Local functions
void CheckOnAny(Result <int, CustomErrorTest> result)
{
int counter = 0;
float res = result.OnAny(r =>
{
++counter;
return(12.5f);
});
Assert.AreEqual(1, counter);
Assert.AreEqual(12.5f, res);
}
void CheckOnAnyNoInput(Result <int, CustomErrorTest> result)
{
int counter = 0;
float res = result.OnAny(() =>
{
++counter;
return(13.5f);
});
Assert.AreEqual(1, counter);
Assert.AreEqual(13.5f, res);
}
#endregion
// Ok result
var ok = Result.Ok <int, CustomErrorTest>(46);
CheckOnAny(ok);
CheckOnAnyNoInput(ok);
// Warning result
var warning = Result.Warn <int, CustomErrorTest>(96, "My warning");
CheckOnAny(warning);
CheckOnAnyNoInput(warning);
// Failure result
var customErrorObject = new CustomErrorTest {
ErrorCode = -28
};
var failure = Result.Fail <int, CustomErrorTest>("My failure", customErrorObject);
CheckOnAny(failure);
CheckOnAnyNoInput(failure);
Assert.Throws <ArgumentNullException>(() => ok.OnAny((Func <float>)null));
Assert.Throws <ArgumentNullException>(() => ok.OnAny((Func <Result <int, CustomErrorTest>, float>)null));
}
public void CastValueCustomResultTInToValueCustomResultTOut()
{
var customErrorObject = new CustomErrorTest {
ErrorCode = -4
};
int counterValueFactory = 0;
// Result ok
var ok = Result.Ok <int, CustomErrorTest>(65);
var result = ok.Cast(
value =>
{
++counterValueFactory;
return(value + 0.1f);
});
Assert.AreEqual(1, counterValueFactory);
CheckResultOk(result, 65.1f);
// Result warn
var warning = Result.Warn <int, CustomErrorTest>(44, "My warning");
result = warning.Cast(
value =>
{
++counterValueFactory;
return(value + 0.1f);
});
Assert.AreEqual(2, counterValueFactory);
CheckResultWarn(result, 44.1f, "My warning");
// Result fail
var failure = Result.Fail <int, CustomErrorTest>("My failure", customErrorObject);
result = failure.Cast(
value =>
{
++counterValueFactory;
return(value + 0.1f);
});
Assert.AreEqual(2, counterValueFactory);
CheckResultFail(result, "My failure", customErrorObject);
Assert.Throws <ArgumentNullException>(() => ok.Cast((Func <int, float>)null));
}
public void CustomResultSafeScope()
{
var defaultError = new CustomErrorTest {
ErrorCode = 51
};
CustomResult <CustomErrorTest> result = ResultScope.SafeCustomResult(Result.CustomOk <CustomErrorTest>, () => defaultError);
CheckResultOk(result);
result = ResultScope.SafeCustomResult(Result.CustomOk <CustomErrorTest>, defaultError);
CheckResultOk(result);
result = ResultScope.SafeCustomResult(() => Result.CustomWarn <CustomErrorTest>("My warning"), () => defaultError);
CheckResultWarn(result, "My warning");
result = ResultScope.SafeCustomResult(() => Result.CustomWarn <CustomErrorTest>("My warning"), defaultError);
CheckResultWarn(result, "My warning");
var errorObject = new CustomErrorTest {
ErrorCode = 12
};
result = ResultScope.SafeCustomResult(() => Result.CustomFail("My failure", errorObject), () => defaultError);
CheckResultFail(result, "My failure", errorObject);
result = ResultScope.SafeCustomResult(() => Result.CustomFail("My failure", errorObject), defaultError);
CheckResultFail(result, "My failure", errorObject);
var thrownException = new Exception("My exception");
result = ResultScope.SafeCustomResult(() => throw thrownException, () => defaultError);
CheckResultFail(result, "My exception", defaultError, thrownException);
result = ResultScope.SafeCustomResult(() => throw thrownException, defaultError);
CheckResultFail(result, "My exception", defaultError, thrownException);
Assert.Throws <ArgumentNullException>(() => ResultScope.SafeCustomResult(null, defaultError));
Assert.Throws <ArgumentNullException>(() => ResultScope.SafeCustomResult(null, () => defaultError));
Assert.Throws <ArgumentNullException>(() => ResultScope.SafeCustomResult(Result.CustomOk <CustomErrorTest>, (CustomErrorTest)null));
Assert.Throws <ArgumentNullException>(() => ResultScope.SafeCustomResult(Result.CustomOk <CustomErrorTest>, (Func <CustomErrorTest>)null));
Assert.Throws <ArgumentNullException>(() => ResultScope.SafeCustomResult(null, (CustomErrorTest)null));
Assert.Throws <ArgumentNullException>(() => ResultScope.SafeCustomResult((Func <CustomResult <CustomErrorTest> >)null, (Func <CustomErrorTest>)null));
}
public void ValueCustomResultSafeScope()
{
var defaultError = new CustomErrorTest {
ErrorCode = 51
};
Result <int, CustomErrorTest> result = ResultScope.SafeValueCustomResult(() => Result.Ok <int, CustomErrorTest>(42), () => defaultError);
CheckResultOk(result, 42);
result = ResultScope.SafeValueCustomResult(() => Result.Ok <int, CustomErrorTest>(12), defaultError);
CheckResultOk(result, 12);
result = ResultScope.SafeValueCustomResult(() => Result.Warn <int, CustomErrorTest>(21, "My warning"), () => defaultError);
CheckResultWarn(result, 21, "My warning");
result = ResultScope.SafeValueCustomResult(() => Result.Warn <int, CustomErrorTest>(51, "My warning"), defaultError);
CheckResultWarn(result, 51, "My warning");
var errorObject = new CustomErrorTest {
ErrorCode = 12
};
result = ResultScope.SafeValueCustomResult(() => Result.Fail <int, CustomErrorTest>("My failure", errorObject), () => defaultError);
CheckResultFail(result, "My failure", errorObject);
result = ResultScope.SafeValueCustomResult(() => Result.Fail <int, CustomErrorTest>("My failure", errorObject), defaultError);
CheckResultFail(result, "My failure", errorObject);
var thrownException = new Exception("My exception");
result = ResultScope.SafeValueCustomResult <int, CustomErrorTest>(() => throw thrownException, () => defaultError);
CheckResultFail(result, "My exception", defaultError, thrownException);
result = ResultScope.SafeValueCustomResult <int, CustomErrorTest>(() => throw thrownException, defaultError);
CheckResultFail(result, "My exception", defaultError, thrownException);
Assert.Throws <ArgumentNullException>(() => ResultScope.SafeValueCustomResult((Func <Result <int, CustomErrorTest> >)null, defaultError));
Assert.Throws <ArgumentNullException>(() => ResultScope.SafeValueCustomResult((Func <Result <int, CustomErrorTest> >)null, () => defaultError));
Assert.Throws <ArgumentNullException>(() => ResultScope.SafeValueCustomResult(() => Result.Ok <int, CustomErrorTest>(12), (CustomErrorTest)null));
Assert.Throws <ArgumentNullException>(() => ResultScope.SafeValueCustomResult(() => Result.Ok <int, CustomErrorTest>(12), (Func <CustomErrorTest>)null));
Assert.Throws <ArgumentNullException>(() => ResultScope.SafeValueCustomResult((Func <Result <int, CustomErrorTest> >)null, (CustomErrorTest)null));
Assert.Throws <ArgumentNullException>(() => ResultScope.SafeValueCustomResult((Func <Result <int, CustomErrorTest> >)null, (Func <CustomErrorTest>)null));
}
public void OptionToCustomResult()
{
// Option has value
var customErrorObject = new CustomErrorTest {
ErrorCode = -32
};
var optionInt = Option <int> .Some(42);
CustomResult <CustomErrorTest> result = optionInt.ToCustomResult(customErrorObject);
CheckResultOk(result);
result = optionInt.ToCustomResult(customErrorObject, "Empty optionInt");
CheckResultOk(result);
result = optionInt.ToCustomResult(() => customErrorObject);
CheckResultOk(result);
result = optionInt.ToCustomResult(() => customErrorObject, "Empty optionInt");
CheckResultOk(result);
// Empty Option
var emptyOptionInt = Option <int> .None;
result = emptyOptionInt.ToCustomResult(customErrorObject);
CheckResultFail(result, string.Format(Option.FailedToResultMessage, typeof(int)), customErrorObject);
result = emptyOptionInt.ToCustomResult(customErrorObject, "Empty emptyOptionInt");
CheckResultFail(result, "Empty emptyOptionInt", customErrorObject);
result = emptyOptionInt.ToCustomResult(() => customErrorObject);
CheckResultFail(result, string.Format(Option.FailedToResultMessage, typeof(int)), customErrorObject);
result = emptyOptionInt.ToCustomResult(() => customErrorObject, "Empty emptyOptionInt");
CheckResultFail(result, "Empty emptyOptionInt", customErrorObject);
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
Assert.Throws <ArgumentNullException>(() => optionInt.ToCustomResult((CustomErrorTest)null, "Useless"));
Assert.Throws <ArgumentNullException>(() => optionInt.ToCustomResult((Func <CustomErrorTest>)null, "Useless"));
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
}
public void ValueCustomResultOnFailureToValueCustomResultWithParam()
{
#region Local function
void CheckOnFailure(Result <int, CustomErrorTest> result, bool treatWarningAsError, bool expectFailure)
{
int counterFailure = 0;
Result <int, CustomErrorTest> res = result.OnFailure(r => ++ counterFailure, treatWarningAsError);
Assert.AreEqual(expectFailure ? 1 : 0, counterFailure);
Assert.AreEqual(result, res);
}
void CheckOnFailureFunc(Result <int, CustomErrorTest> result, bool treatWarningAsError, bool expectFailure)
{
int counterFailure = 0;
Result <int, CustomErrorTest> res = result.OnFailure(
r =>
{
++counterFailure;
return(Result.Ok <int, CustomErrorTest>(42));
},
treatWarningAsError);
Assert.AreEqual(expectFailure ? 1 : 0, counterFailure);
if (expectFailure)
{
CheckResultOk(res, 42);
}
else
{
Assert.AreEqual(result, res);
}
}
#endregion
// Ok result
var ok = Result.Ok <int, CustomErrorTest>(66);
CheckOnFailure(ok, false, false);
CheckOnFailure(ok, true, false);
CheckOnFailureFunc(ok, false, false);
CheckOnFailureFunc(ok, true, false);
// Warning result
var warning = Result.Warn <int, CustomErrorTest>(55, "My warning");
CheckOnFailure(warning, false, false);
CheckOnFailure(warning, true, true);
CheckOnFailureFunc(warning, false, false);
CheckOnFailureFunc(warning, true, true);
// Failure result
var customErrorObject = new CustomErrorTest {
ErrorCode = -2
};
var failure = Result.Fail <int, CustomErrorTest>("My failure", customErrorObject);
CheckOnFailure(failure, false, true);
CheckOnFailure(failure, true, true);
CheckOnFailureFunc(failure, false, true);
CheckOnFailureFunc(failure, true, true);
Assert.Throws <ArgumentNullException>(() => ok.OnFailure((Action <Result <int, CustomErrorTest> >)null));
Assert.Throws <ArgumentNullException>(() => ok.OnFailure(null));
}
public void CastResultToValueCustomResult()
{
var customErrorObjectFactory = new CustomErrorTest {
ErrorCode = -8
};
int counterValueFactory = 0;
int counterErrorFactory = 0;
// Result ok
var ok = Result.Ok();
var result = ok.Cast(22, customErrorObjectFactory);
CheckResultOk(result, 22);
result = ok.Cast(11,
() =>
{
++counterErrorFactory;
return(customErrorObjectFactory);
});
Assert.AreEqual(0, counterErrorFactory);
CheckResultOk(result, 11);
result = ok.Cast(
() =>
{
++counterValueFactory;
return(33);
}, customErrorObjectFactory);
Assert.AreEqual(1, counterValueFactory);
CheckResultOk(result, 33);
result = ok.Cast(
() =>
{
++counterValueFactory;
return(44);
},
() =>
{
++counterErrorFactory;
return(customErrorObjectFactory);
});
Assert.AreEqual(2, counterValueFactory);
Assert.AreEqual(0, counterErrorFactory);
CheckResultOk(result, 44);
// Result warn
var warning = Result.Warn("My warning");
result = warning.Cast(22, customErrorObjectFactory);
CheckResultWarn(result, 22, "My warning");
result = warning.Cast(11,
() =>
{
++counterErrorFactory;
return(customErrorObjectFactory);
});
Assert.AreEqual(0, counterErrorFactory);
CheckResultWarn(result, 11, "My warning");
result = warning.Cast(
() =>
{
++counterValueFactory;
return(33);
}, customErrorObjectFactory);
Assert.AreEqual(3, counterValueFactory);
CheckResultWarn(result, 33, "My warning");
result = warning.Cast(
() =>
{
++counterValueFactory;
return(44);
},
() =>
{
++counterErrorFactory;
return(customErrorObjectFactory);
});
Assert.AreEqual(4, counterValueFactory);
Assert.AreEqual(0, counterErrorFactory);
CheckResultWarn(result, 44, "My warning");
// Result fail
var failure = Result.Fail("My failure");
result = failure.Cast(22, customErrorObjectFactory);
CheckResultFail(result, "My failure", customErrorObjectFactory);
result = failure.Cast(11,
() =>
{
++counterErrorFactory;
return(customErrorObjectFactory);
});
Assert.AreEqual(1, counterErrorFactory);
CheckResultFail(result, "My failure", customErrorObjectFactory);
result = failure.Cast(
() =>
{
++counterValueFactory;
return(33);
},
customErrorObjectFactory);
Assert.AreEqual(4, counterValueFactory);
CheckResultFail(result, "My failure", customErrorObjectFactory);
result = failure.Cast(
() =>
{
++counterValueFactory;
return(44);
},
() =>
{
++counterErrorFactory;
return(customErrorObjectFactory);
});
Assert.AreEqual(4, counterValueFactory);
Assert.AreEqual(2, counterErrorFactory);
CheckResultFail(result, "My failure", customErrorObjectFactory);
// ReSharper disable ReturnValueOfPureMethodIsNotUsed
Assert.Throws <ArgumentNullException>(() => ok.Cast(12.5f, (CustomErrorTest)null));
Assert.Throws <ArgumentNullException>(() => ok.Cast(12.5f, (Func <CustomErrorTest>)null));
Assert.Throws <ArgumentNullException>(() => ok.Cast(() => 12.5f, (CustomErrorTest)null));
Assert.Throws <ArgumentNullException>(() => ok.Cast(() => 12.5f, (Func <CustomErrorTest>)null));
Assert.Throws <ArgumentNullException>(() => ok.Cast((Func <float>)null, (CustomErrorTest)null));
Assert.Throws <ArgumentNullException>(() => ok.Cast((Func <float>)null, (Func <CustomErrorTest>)null));
// ReSharper restore ReturnValueOfPureMethodIsNotUsed
}
public void CastValueResultToValueCustomResultWithAs()
{
var testObject = new TestClass();
var testObjectLeaf = new TestClassLeaf();
var customErrorObjectFactory = new CustomErrorTest {
ErrorCode = -8
};
int counterErrorFactory = 0;
// Result ok
var ok = Result.Ok <TestClass>(testObjectLeaf);
var result = ok.Cast <TestClassLeaf, CustomErrorTest>(customErrorObjectFactory);
CheckResultOk(result, testObjectLeaf);
result = ok.Cast <TestClassLeaf, CustomErrorTest>(
() =>
{
++counterErrorFactory;
return(customErrorObjectFactory);
});
Assert.AreEqual(0, counterErrorFactory);
CheckResultOk(result, testObjectLeaf);
ok = Result.Ok(testObject);
result = ok.Cast <TestClassLeaf, CustomErrorTest>(customErrorObjectFactory);
CheckResultOk(result, null);
result = ok.Cast <TestClassLeaf, CustomErrorTest>(
() =>
{
++counterErrorFactory;
return(customErrorObjectFactory);
});
Assert.AreEqual(0, counterErrorFactory);
CheckResultOk(result, null);
// Result warn
var warning = Result.Warn <TestClass>(testObjectLeaf, "My warning");
result = warning.Cast <TestClassLeaf, CustomErrorTest>(customErrorObjectFactory);
CheckResultWarn(result, testObjectLeaf, "My warning");
result = warning.Cast <TestClassLeaf, CustomErrorTest>(
() =>
{
++counterErrorFactory;
return(customErrorObjectFactory);
});
Assert.AreEqual(0, counterErrorFactory);
CheckResultWarn(result, testObjectLeaf, "My warning");
warning = Result.Warn(testObject, "My warning");
result = warning.Cast <TestClassLeaf, CustomErrorTest>(customErrorObjectFactory);
CheckResultWarn(result, null, "My warning");
result = warning.Cast <TestClassLeaf, CustomErrorTest>(
() =>
{
++counterErrorFactory;
return(customErrorObjectFactory);
});
Assert.AreEqual(0, counterErrorFactory);
CheckResultWarn(result, null, "My warning");
// Result fail
var failure = Result.Fail <TestClass>("My failure");
result = failure.Cast <TestClassLeaf, CustomErrorTest>(customErrorObjectFactory);
CheckResultFail(result, "My failure", customErrorObjectFactory);
result = failure.Cast <TestClassLeaf, CustomErrorTest>(
() =>
{
++counterErrorFactory;
return(customErrorObjectFactory);
});
Assert.AreEqual(1, counterErrorFactory);
CheckResultFail(result, "My failure", customErrorObjectFactory);
Assert.Throws <ArgumentNullException>(() => ok.Cast <TestClass, CustomErrorTest>((CustomErrorTest)null));
Assert.Throws <ArgumentNullException>(() => ok.Cast <TestClass, CustomErrorTest>((Func <CustomErrorTest>)null));
}
public void ResultLogicErrorEquality()
{
var customErrorObject1 = new CustomErrorTest {
ErrorCode = -2
};
var customErrorObject2 = new CustomErrorTest {
ErrorCode = -3
};
// Logics
var logicOk1 = new ResultLogic <CustomErrorTest>();
var logicOk2 = new ResultLogic <CustomErrorTest>();
var logicOkTmp = logicOk1;
var logicWarn1 = new ResultLogic <CustomErrorTest>(true, "My warning", null, null);
var logicWarn2 = new ResultLogic <CustomErrorTest>(true, "My warning", null, null);
var logicWarn3 = new ResultLogic <CustomErrorTest>(true, "My warning 2", null, null);
var logicWarnTmp = logicWarn1;
var logicFail1 = new ResultLogic <CustomErrorTest>(false, "My failure", customErrorObject1, null);
var logicFail2 = new ResultLogic <CustomErrorTest>(false, "My failure", customErrorObject1, null);
var logicFail3 = new ResultLogic <CustomErrorTest>(false, "My failure", customErrorObject2, null);
var logicFail4 = new ResultLogic <CustomErrorTest>(false, "My failure 2", customErrorObject1, null);
var logicFailTmp = logicFail1;
// Checks Ok
Assert.AreEqual(logicOk1, logicOk1);
Assert.IsTrue(logicOk1 == logicOkTmp);
Assert.IsFalse(logicOk1 != logicOkTmp);
Assert.AreEqual(logicOk1, logicOk2);
Assert.AreEqual(logicOk2, logicOk1);
Assert.IsTrue(logicOk1 == logicOk2);
Assert.IsFalse(logicOk1 != logicOk2);
// Checks Warn
Assert.AreEqual(logicWarn1, logicWarn1);
Assert.IsTrue(logicWarn1 == logicWarnTmp);
Assert.IsFalse(logicWarn1 != logicWarnTmp);
Assert.AreEqual(logicWarn1, logicWarn2);
Assert.AreEqual(logicWarn2, logicWarn1);
Assert.IsTrue(logicWarn1 == logicWarn2);
Assert.IsFalse(logicWarn1 != logicWarn2);
Assert.AreNotEqual(logicWarn1, logicWarn3);
Assert.AreNotEqual(logicWarn3, logicWarn1);
Assert.IsFalse(logicWarn1 == logicWarn3);
Assert.IsTrue(logicWarn1 != logicWarn3);
// Checks Fail
Assert.AreEqual(logicFail1, logicFail1);
Assert.IsTrue(logicFail1 == logicFailTmp);
Assert.IsFalse(logicFail1 != logicFailTmp);
Assert.AreEqual(logicFail1, logicFail2);
Assert.AreEqual(logicFail2, logicFail1);
Assert.IsTrue(logicFail1 == logicFail2);
Assert.IsFalse(logicFail1 != logicFail2);
Assert.AreNotEqual(logicFail1, logicFail3);
Assert.AreNotEqual(logicFail3, logicFail1);
Assert.IsFalse(logicFail1 == logicFail3);
Assert.IsTrue(logicFail1 != logicFail3);
Assert.AreNotEqual(logicFail1, logicFail4);
Assert.AreNotEqual(logicFail4, logicFail1);
Assert.IsFalse(logicFail1 == logicFail4);
Assert.IsTrue(logicFail1 != logicFail4);
// Mixed
Assert.AreNotEqual(logicOk1, new TestClass());
Assert.AreNotEqual(new TestClass(), logicOk1);
// Checks with null
Assert.AreNotEqual(logicOk1, null);
Assert.AreNotEqual(null, logicOk1);
Assert.IsFalse(logicOk1.Equals(null));
Assert.IsFalse(logicOk1.Equals((object)null));
Assert.IsFalse(logicOk1 == null);
Assert.IsFalse(null == logicOk1);
Assert.IsTrue(logicOk1 != null);
Assert.IsTrue(null != logicOk1);
}
