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