void M <SomeTypeParameter>(
SomeClass a,
SomeStruct b,
SomeRecord c,
SomeEnum d,
SomeInterface e,
SomeDelegate f,
SomeTypeParameter g)
{
}
public void Forward_SourceIsDefault_ExpectDefault(
Result <RefType, StructType> source)
{
Result <SomeRecord, StructType> next = new SomeRecord();
var actual = source.Forward(_ => next);
var expected = default(Result <SomeRecord, StructType>);
Assert.AreEqual(expected, actual);
}
public void ForwardMapFailure_SourceIsDefaultOrFailure_ExpectResultOfMappedFailure(
Result <RefType, StructType> source)
{
Result <SomeRecord, SomeError> next = new SomeRecord();
var mappedFailure = new SomeError(MinusFifteen);
var actual = source.Forward(_ => next, _ => mappedFailure);
var expected = new Result <SomeRecord, SomeError>(mappedFailure);
Assert.AreEqual(expected, actual);
}
public async Task ForwardAsyncMapFailure_SourceIsDefaultOrFailure_ExpectResultOfMappedFailure(
Result <RefType, StructType> source)
{
Result <SomeRecord, SomeError> next = new SomeRecord();
var mappedFailure = new SomeError(MinusFifteen);
var actual = await source.ForwardAsync(_ => Task.FromResult(next), _ => Task.FromResult(mappedFailure));
var expected = new Result <SomeRecord, SomeError>(mappedFailure);
Assert.AreEqual(expected, actual);
}
public async Task RecoverValueAsyncWithMapSuccess_SourceIsDefaultOrFailureAndOtherIsFailure_ExpectOther(
Result <RefType, StructType> source)
{
var other = new Result <SomeRecord, SomeError>(new SomeError(PlusFifteen));
var mappedValue = new SomeRecord
{
Text = "Some record text property value"
};
var actual = await source.RecoverValueAsync(_ => ValueTask.FromResult(other), _ => ValueTask.FromResult(mappedValue));
Assert.AreEqual(other, actual);
}
public async Task RecoverAsyncWithMapSuccess_SourceIsDefaultOrFailureAndOtherIsSuccess_ExpectOther(
Result <RefType, StructType> source)
{
var other = Result.Success(new SomeRecord()).With <SomeError>();
var mappedSuccess = new SomeRecord
{
Text = "Some property value"
};
var actual = await source.RecoverAsync(_ => Task.FromResult(other), _ => Task.FromResult(mappedSuccess));
Assert.AreEqual(other, actual);
}
public void MapValueAsync_MapFailureAsyncIsNull_ExpectArgumentNullException(
Result <RefType, StructType> source)
{
var successResult = new SomeRecord
{
Text = SomeString
};
var actualException = Assert.ThrowsAsync <ArgumentNullException>(
async() => _ = await source.MapValueAsync <SomeRecord, int>(_ => ValueTask.FromResult(successResult), null !));
Assert.AreEqual("mapFailureAsync", actualException !.ParamName);
}
public void TaggedUnion_ToResult_SourceUnionIsFirstAndSourceValueIsNotNull_ExpectSuccessResultOfSourceValue()
{
var sourceValue = new SomeRecord
{
Text = SomeString
};
var sourceUnion = TaggedUnion <SomeRecord, SomeError> .First(sourceValue);
var actual = sourceUnion.ToResult();
var expected = Result <SomeRecord, SomeError> .Success(sourceValue);
Assert.AreEqual(expected, actual);
}
public void FoldAsync_MapSuccessAsyncIsNull_ExpectArgumentNullException(
Result <RefType, StructType> source)
{
var failureResult = new SomeRecord
{
Text = SomeString
};
var actualException = Assert.ThrowsAsync <ArgumentNullException>(
async() => _ = await source.FoldAsync(null !, _ => Task.FromResult(failureResult)));
Assert.AreEqual("mapSuccessAsync", actualException !.ParamName);
}
public void RecoverValueAsyncWithMapSuccess_OtherFactoryAsyncIsNull_ExpectArgumentNullException(
Result <RefType, StructType> source)
{
var mappedSuccess = new SomeRecord
{
Text = "Some Property Value"
};
var actualException = Assert.ThrowsAsync <ArgumentNullException>(
async() => _ = await source.RecoverValueAsync <SomeRecord, SomeError>(null !, _ => ValueTask.FromResult(mappedSuccess)));
Assert.AreEqual("otherFactoryAsync", actualException !.ParamName);
}
public void Map_SourceIsSuccess_ExpectSuccessResultOfMapSuccess(
Result <RefType, StructType> source)
{
var successResult = new SomeRecord();
var failureResult = new SomeError(MinusFifteen);
var actual = source.Map(
_ => successResult,
_ => failureResult);
var exected = new Result <SomeRecord, SomeError>(successResult);
Assert.AreEqual(exected, actual);
}
public async Task MapSuccessAsync_SourceIsSuccess_ExpectSuccessResultOfMapSuccessAsync(
Result <RefType, StructType> source)
{
var successResult = new SomeRecord
{
Text = SomeString
};
var actual = await source.MapSuccessAsync(
_ => Task.FromResult(successResult));
var exected = new Result <SomeRecord, StructType>(successResult);
Assert.AreEqual(exected, actual);
}
public void MapSuccess_SourceIsSuccess_ExpectSuccessResultOfMapSuccess(
Result <RefType, StructType> source)
{
var successResult = new SomeRecord
{
Text = SomeString
};
var actual = source.MapSuccess(
_ => successResult);
var exected = new Result <SomeRecord, StructType>(successResult);
Assert.AreEqual(exected, actual);
}
public async Task MapValueAsync_SourceIsDefaultOrFailure_ExpectFailureResultOfMapFailure(
Result <RefType, StructType> source)
{
var successResult = new SomeRecord
{
Text = SomeString
};
var failureResult = int.MaxValue;
var actual = await source.MapValueAsync(
_ => ValueTask.FromResult(successResult),
_ => ValueTask.FromResult(failureResult));
var exected = new Result <SomeRecord, int>(failureResult);
Assert.AreEqual(exected, actual);
}
public void RecoverWithMapSuccess_SourceIsSuccess_ExpectSuccessResultOfMappedValue(
Result <RefType, StructType> source)
{
Result <SomeRecord, SomeError> other = new SomeRecord
{
Text = SomeString
};
var mappedSuccess = new SomeRecord
{
Text = TabString
};
var actual = source.Recover(_ => other, _ => mappedSuccess);
var expected = new Result <SomeRecord, SomeError>(mappedSuccess);
Assert.AreEqual(expected, actual);
}
public async Task MapAsync_SourceIsDefaultOrFailure_ExpectFailureResultOfMapFailure(
Result <RefType, StructType> source)
{
var successResult = new SomeRecord
{
Text = EmptyString
};
var failureResult = default(SomeError);
var actual = await source.MapAsync(
_ => Task.FromResult(successResult),
_ => Task.FromResult(failureResult));
var exected = new Result <SomeRecord, SomeError>(failureResult);
Assert.AreEqual(exected, actual);
}
public void Map_SourceIsDefaultOrFailure_FailureExpectResultOfMapFailure(
Result <RefType, StructType> source)
{
var successResult = new SomeRecord
{
Text = SomeString
};
var failureResult = default(SomeError);
var actual = source.Map(
_ => successResult,
_ => failureResult);
var exected = new Result <SomeRecord, SomeError>(failureResult);
Assert.AreEqual(exected, actual);
}
public void Fold_SourceIsDefaultOrFailure_ExpectResultOfMapFailure(
Result <RefType, StructType> source)
{
var successResult = new SomeRecord
{
Text = SomeString
};
var failureResult = new SomeRecord
{
Text = ThreeWhiteSpacesString
};
var actual = source.Fold(
_ => successResult,
_ => failureResult);
Assert.AreEqual(failureResult, actual);
}
public async Task RecoverValueAsyncWithMapSuccess_SourceIsSuccess_ExpectSuccessResultOfMappedValue(
Result <RefType, StructType> source)
{
Result <SomeRecord, SomeError> other = new SomeRecord
{
Text = "Some other property value"
};
var mappedSuccess = new SomeRecord
{
Text = null
};
var actual = await source.RecoverValueAsync(_ => ValueTask.FromResult(other), _ => ValueTask.FromResult(mappedSuccess));
var expected = Result.Success(mappedSuccess).With <SomeError>();
Assert.AreEqual(expected, actual);
}
public async Task FoldAsync_SourceIsDefaultOrFailure_ExpectResultOfMapFailure(
Result <RefType, StructType> source)
{
var successResult = new SomeRecord
{
Text = EmptyString
};
var failureResult = new SomeRecord
{
Text = SomeString
};
var actual = await source.FoldAsync(
_ => Task.FromResult(successResult),
_ => Task.FromResult(failureResult));
Assert.AreEqual(failureResult, actual);
}
public void EqualsInequality_ResultAIsSuccessAndResultBIsSuccessAndValuesAreEqual_ExpectFalse()
{
var text = "Some new text.";
var aValue = new SomeRecord
{
Text = text
};
var resultA = Result <SomeRecord, StructType> .Success(aValue);
var bValue = new SomeRecord
{
Text = text
};
var resultB = new Result <SomeRecord, StructType>(bValue);
var actual = resultA != resultB;
Assert.False(actual);
}
public void EqualsEquality_ResultAIsSuccessAndResultBIsSuccessAndValuesAreEqual_ExpectTrue()
{
var text = "Some new text.";
var aValue = new SomeRecord
{
Text = text
};
var resultA = Result <SomeRecord, SomeError> .Success(aValue);
var bValue = new SomeRecord
{
Text = text
};
var resultB = new Result <SomeRecord, SomeError>(bValue);
var actual = resultA == resultB;
Assert.True(actual);
}
public void Equals_ResultAIsSuccessAndResultBIsSuccessAndValuesAreEqual_ExpectTrue()
{
var text = "Some new text.";
var aValue = new SomeRecord
{
Text = text
};
var resultA = Result.Success(aValue).With <SomeError>();
var bValue = new SomeRecord
{
Text = text
};
Result <SomeRecord, SomeError> resultB = bValue;
var actual = Result.Equals(resultA, resultB);
Assert.True(actual);
}
public void EqualsOther_SourceIsSuccessAndOtherIsSuccessAndValuesAreEqual_ExpectTrue()
{
var text = "Some new text.";
var sourceValue = new SomeRecord
{
Text = text
};
var source = Result <SomeRecord, SomeError> .Success(sourceValue);
var otherValue = new SomeRecord
{
Text = text
};
Result <SomeRecord, SomeError> other = otherValue;
var actual = source.Equals(other);
Assert.True(actual);
}
public void EqualsStatic_ResultAIsSuccessAndResultBIsSuccessAndValuesAreEqual_ExpectTrue()
{
var text = "Some new text.";
var aValue = new SomeRecord
{
Text = text
};
var resultA = Result <SomeRecord, StructType> .Success(aValue);
var bValue = new SomeRecord
{
Text = text
};
Result <SomeRecord, StructType> resultB = bValue;
var actual = Result <SomeRecord, StructType> .Equals(resultA, resultB);
Assert.True(actual);
}
public void EqualsObject_SourceIsSuccessAndObjectIsSuccessAndValuesAreEqual_ExpectTrue()
{
var text = SomeString;
var sourceValue = new SomeRecord
{
Text = text
};
var source = Result <SomeRecord?, SomeError> .Success(sourceValue);
var objValue = new SomeRecord
{
Text = text
};
object?obj = Result <SomeRecord, SomeError> .Success(objValue);
var actual = source.Equals(obj);
Assert.True(actual);
}
public void GetHashCode_SourceIsSuccessAndOtherIsSuccessAndValuesAreEqual_ExpectHashCodesAreEqual()
{
var text = "Some new text.";
var sourceValue = new SomeRecord
{
Text = text
};
var source = Result <SomeRecord?, int> .Success(sourceValue);
var otherValue = new SomeRecord
{
Text = text
};
Result <SomeRecord, int> other = otherValue;
var sourceHashCode = source.GetHashCode();
var otherHashCode = other.GetHashCode();
Assert.AreEqual(sourceHashCode, otherHashCode);
}
public void EqualsOther_SourceSuccessIsEqualOtherSuccess_ExpectTrue()
{
var text = "Some property string value";
var sourceSuccess = new SomeRecord
{
Text = text
};
var source = Result.Success(sourceSuccess);
var otherSuccess = new SomeRecord
{
Text = text
};
var other = Result.Success(otherSuccess);
var actual = source.Equals(other);
Assert.True(actual);
}
public void Equality_LeftSuccessIsEqualRightSuccess_ExpectTrue()
{
var text = "Some property string value";
var leftSuccess = new SomeRecord
{
Text = text
};
var left = Result.Success(leftSuccess);
var rightSuccess = new SomeRecord
{
Text = text
};
var right = Result.Success(rightSuccess);
var actual = left == right;
Assert.True(actual);
}
