public void BindMultipleResultsTogetherError() { var res = FakeService.DoDivision(10, 2) .Bind(() => FakeService.DoDivision(20, 0)) .Bind(() => FakeService.DoDivision(4, 2)); Assert.False(res.IsOk); }
public void BindDifferentTypesTogether() { var res = FakeService.DoDivision(100, 2) .Bind((x) => FakeService.DoStringStuff(x.ToString())); Assert.True(res.IsOk); Assert.Equal("*** 50 ***", res.GetSuccess <string>().Value); }
public void BindDifferentTypesTogetherWithOnesThatOnlyReturnResult() { IResult res = FakeService.DoDivision(100, 2) .Bind((x) => FakeService.DoStringStuff(x.ToString())) .Bind(FakeService.FakeVoidMethod); Assert.True(res.IsOk); }
public void BindMultipleResultsWithValueTogetherOk() { var res = FakeService.DoDivision(200, 2) .Bind((x) => FakeService.DoDivision(x, 2)) .Bind((x) => FakeService.DoDivision(x, 2)); Assert.True(res.IsOk); Assert.Equal(25.0, res.GetSuccess <double>().Value); }
public void BindMultipleResultsWithValueTogetherError() { var res = FakeService.DoDivision(100, 2) .Bind((x) => FakeService.DoDivision((int)x, 0)) .Bind((x) => FakeService.DoDivision((int)x, 2)); Assert.False(res.IsOk); Assert.IsType <DivideByZeroException>(res.GetError <double>().ExceptionValue); }
public void BindDifferentTypesTogetherIgnoringPreviousResult() { //This should never be done, but for the shake of it... var res = FakeService.DoDivision(100, 2) .Bind((x) => FakeService.DoStringStuff(x.ToString())) .Bind((s) => FakeService.DoDivision(10, 2)); Assert.True(res.IsOk); Assert.Equal(5.0, res.GetSuccess <double>().Value); }
public void DivideByZeroHandled() { // Arrange. // Act. IResult result = FakeService.DoDivision(10, 0); // Assert. Assert.True(result is Error); Assert.True(result.IsError()); }
public void DontAllowExtractingValueSafelyFromResultOnlySuccess() { // Arrange. IResult <double> operationResult = FakeService.DoDivision(10, 2); // Act. Success <double> success = operationResult.GetSuccessSafe <double>().Value; // Assert. Assert.Equal(5.0, success.Value); }
public void DivideWithoutErrorHandled() { // Arrange. // Act. IResult result = FakeService.DoDivision(10, 2); // Assert. Assert.True(result is Success); Assert.Equal(5, (result as Success <double>).Value); Assert.Equal(typeof(double), result.GetResultType()); }
public void TestImplicitOperatorInSuccessSafe() { // Arrange. IResult <double> result = FakeService.DoDivision(10, 2); // Act. var divResult = result.GetSuccessSafe <double>(); // Assert. Assert.Equal(5.0, divResult.Value); }
public void ExtractSuccess() { // Arrange. // Act. IResult result = FakeService.DoDivision(10, 2); Success successUntyped = result.GetSuccess(); // Assert. Assert.True(successUntyped is Success); Assert.True(successUntyped is Success <double>); }
public void TestImplicitOperatorInSuccessOfTDirectlyToT() { // Arrange. IResult <double> result = FakeService.DoDivision(10, 2); // Act. double divResult = result.GetSuccess(); // Assert. Assert.Equal(5.0, divResult); }
public void ExtractSuccessTyped() { // Arrange. // Act. IResult result = FakeService.DoDivision(10, 2); Success <double> successTyped = result.GetSuccess <double>(); // Assert. Assert.True(successTyped is Success); Assert.True(successTyped.IsOk); Assert.False(successTyped.IsVoid); }
public void DivideByZeroHandledWithSpecificException() { // Arrange. // Act. IResult <double> result = FakeService.DoDivision(10, 0); // Assert. Assert.True(result is Error); Assert.True(result is Error <double>); Assert.True(result.IsError()); Assert.Equal(typeof(DivideByZeroException), result.GetResultType()); }
public void ExtractError() { // Arrange. // Act. IResult <double> result = FakeService.DoDivision(10, 0); Error errorUntyped = result.GetError(); Type exceptionType = errorUntyped.GetResultType(); // Assert. Assert.True(errorUntyped is Error); Assert.True(errorUntyped is Error <double>); Assert.Equal(typeof(DivideByZeroException), exceptionType); }
public void ExtractErrorTyped() { // Arrange. // Act. IResult result = FakeService.DoDivision(10, 0); var errorTyped = result.GetError <double>(); Type exceptionType = errorTyped.GetResultType(); // Assert. Assert.True(errorTyped is Error); Assert.Equal(typeof(DivideByZeroException), exceptionType); Assert.False(errorTyped.IsOk); Assert.False(errorTyped.IsVoid); }
public void ExtractErrorTypedSafely() { // Arrange. // Act. var result = FakeService.DoDivision(10, 0); (Error <double>, Exception)errorTuple = result.GetErrorSafe <double>(); var error = errorTuple.GetValue(); // Assert. Assert.True(error is Error <double>); Assert.Equal(typeof(DivideByZeroException), error.GetResultType()); Assert.Equal(typeof(double), error.Value.GetType()); }
public void ExtractSuccessSafely() { // Arrange. // Act. IResult result = FakeService.DoDivision(10, 2); (Success, Exception)tuple = result.GetSuccessSafe(); Success success = tuple.GetValue(); // Assert. Assert.True(success is Success); Assert.NotNull(success); Assert.True(tuple.IsSuccessful()); Assert.NotNull(tuple.Item1); Assert.Null(tuple.Item2); }
public void ExtractErrorSafely() { // Arrange. // Act. IResult result = FakeService.DoDivision(10, 0); (Error, Exception)tuple = result.GetErrorSafe(); Error error = tuple.GetValue(); // Assert. Assert.True(error is Error); Assert.True(tuple.IsSuccessful()); Assert.False(tuple.IsUnsuccesful()); Assert.NotNull(tuple.Item1); Assert.Null(tuple.Item2); }
public void ExtractSuccessTypedSafely() { // Arrange. // Act. IResult result = FakeService.DoDivision(10, 2); (Success <double>, Exception)tuple = result.GetSuccessSafe <double>(); var success = tuple.GetValue(); // Assert. Assert.True(success is Success); Assert.True(success is Success <double>); Assert.Equal(5, success.Value); Assert.True(tuple.IsSuccessful()); Assert.NotNull(tuple.Item1); Assert.Null(tuple.Item2); }