public void ApplySequenceOfValueTypeRefParametersArrangementFunc()
{
// Given
var type = typeof(IFooFuncValueTypeParameterRef <int>);
var methodName = nameof(IFooFuncValueTypeParameterRef <int> .MethodWithOneParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var refParameterFeature = new ParameterRef(signature, new object[] { 9 });
var invocation = new Invocation(signature, refParameterFeature);
var arrangment = new RefParameterSequenceArrangement <int>(signature, "first", new List <int> {
13, 42, 65
});
// When
var feature = invocation.GetFeature <IParameterRef>();
arrangment.ApplyTo(invocation);
var first = feature.RefParameterCollection.First().Value;
arrangment.ApplyTo(invocation);
var second = feature.RefParameterCollection.First().Value;
arrangment.ApplyTo(invocation);
var third = feature.RefParameterCollection.First().Value;
arrangment.ApplyTo(invocation);
var fourth = feature.RefParameterCollection.First().Value;
// Then
Assert.Equal(13, first);
Assert.Equal(42, second);
Assert.Equal(65, third);
Assert.Equal(65, fourth);
}
public void TryApplySequenceOfValueTypeOutParametersArrangementFunc()
{
// Given
var type = typeof(IFooFuncValueTypeParameterOut <int>);
var methodName = nameof(IFooFuncValueTypeParameterOut <int> .MethodWithOneParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var outParameterFeature = new ParameterOut(signature);
var invocation = new Invocation(signature, outParameterFeature);
var arrangment = new OutParameterSequenceArrangement <int>(signature, "first", new List <int> {
13, 42, 65
});
// When
var feature = invocation.GetFeature <IParameterOut>();
var wasFirstApplied = arrangment.TryApplyTo(invocation);
var first = feature.OutParameterCollection.First().Value;
var wasSecondApplied = arrangment.TryApplyTo(invocation);
var second = feature.OutParameterCollection.First().Value;
var wasThirdApplied = arrangment.TryApplyTo(invocation);
var third = feature.OutParameterCollection.First().Value;
var wasFourthApplied = arrangment.TryApplyTo(invocation);
var fourth = feature.OutParameterCollection.First().Value;
// Then
Assert.True(wasFirstApplied);
Assert.Equal(13, first);
Assert.True(wasSecondApplied);
Assert.Equal(42, second);
Assert.True(wasThirdApplied);
Assert.Equal(65, third);
Assert.True(wasFourthApplied);
Assert.Equal(65, fourth);
}
public void CanApplySequenceWithNonMatchingParameterReturnsFalseFunc()
{
// Given
var type = typeof(IFooFuncValueTypeParameterRef <int>);
var methodName = nameof(IFooFuncValueTypeParameterRef <int> .MethodWithOneParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var refParameterFeature = new ParameterRef(signature, new object[] { 9 });
var invocation = new Invocation(signature, refParameterFeature);
var arrangment = new RefParameterSequenceArrangement <int>(signature, "WrongParameterName", new List <int> {
42
});
// When
var canApply = arrangment.CanApplyTo(invocation);
// Then
Assert.False(canApply);
Assert.True(invocation.HasFeature <IParameterRef>());
var feature = invocation.GetFeature <IParameterRef>();
Assert.Single(feature.RefParameterCollection);
var parameter = feature.RefParameterCollection.Single();
Assert.Equal(9, parameter.Value);
}
public void EnsureTryApplySequenceIsFalseForNonMatchingInvocationFunc()
{
// Given
var type = typeof(IFooFuncValueTypeParameterRef <int>);
var methodName = nameof(IFooFuncValueTypeParameterRef <int> .MethodWithOneParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var refParameterFeature = new ParameterRef(signature, new object[] { 9 });
var invocation = new Invocation(signature, refParameterFeature);
var arrangment = new RefParameterSequenceArrangement <int>(signature, "WrongParameterName", new List <int> {
13, 42, 65
});
// When
var wasApplied = arrangment.TryApplyTo(invocation);
// Then
Assert.False(wasApplied);
Assert.True(invocation.HasFeature <IParameterRef>());
var feature = invocation.GetFeature <IParameterRef>();
Assert.Single(feature.RefParameterCollection);
var parameter = feature.RefParameterCollection.Single();
Assert.Equal("first", parameter.Name);
Assert.Equal(typeof(int), parameter.Type);
Assert.Equal(9, parameter.Value);
}
public void EnsureNoArrangentIsAppliedToNonMatchingInvocationFunc()
{
// Given
var type = typeof(IFooFuncValueTypeParameterRef <int>);
var methodName = nameof(IFooFuncValueTypeParameterRef <int> .MethodWithOneParameter);
var valueTypeSignature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
type = typeof(IFooFuncReferenceTypeParameterRef <object>);
methodName = nameof(IFooFuncReferenceTypeParameterRef <object> .MethodWithOneParameter);
var referenceTypeSignature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var refParameterFeature = new ParameterRef(valueTypeSignature, new object[] { 9 });
var invocation = new Invocation(valueTypeSignature, refParameterFeature);
var arrangment = new RefParameterSequenceArrangement <object>(
referenceTypeSignature, "first", new List <object> {
new object()
});
// When
arrangment.ApplyTo(invocation);
// Then
Assert.True(invocation.HasFeature <IParameterRef>());
var feature = invocation.GetFeature <IParameterRef>();
Assert.Single(feature.RefParameterCollection);
var parameter = feature.RefParameterCollection.Single();
Assert.Equal(9, parameter.Value);
}
public void TryApplyReferenceTypeRefParameterArrangement()
{
// Given
var expectedValue = new object();
var type = typeof(IFooActionReferenceTypeParameterRef <object>);
var methodName = nameof(IFooActionReferenceTypeParameterRef <object> .MethodWithOneParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var refParameterFeature = new ParameterRef(signature, new object?[] { null });
var invocation = new Invocation(signature, refParameterFeature);
var arrangment = new RefParameterArrangement <object?>(signature, "first", expectedValue);
// When
var wasApplied = arrangment.TryApplyTo(invocation);
// Then
Assert.True(wasApplied);
Assert.True(invocation.HasFeature <IParameterRef>());
var feature = invocation.GetFeature <IParameterRef>();
Assert.Single(feature.RefParameterCollection);
var parameter = feature.RefParameterCollection.Single();
Assert.Equal("first", parameter.Name);
Assert.Equal(typeof(object), parameter.Type);
Assert.Equal(expectedValue, parameter.Value);
}
public void ApplySequenceOfReferenceTypeReturnValuesArrangement()
{
// Given
var value1 = new object();
var value2 = new object();
var value3 = new object();
var signature = typeof(IFooFuncReferenceTypeParameterless <object>)
.GetMethod(nameof(IFooFuncReferenceTypeParameterless <object> .MethodWithoutParameter)) ?? throw new InvalidOperationException();
var returnValueFeature = new ReturnValueInvocation <object?>();
var invocation = new Invocation(signature, returnValueFeature);
var arrangment = new ReturnValueSequenceArrangement <object?>(signature, new List <object?>(new[] { value1, value2, value3 }));
// When
var feature = invocation.GetFeature <IReturnValue <object?> >();
arrangment.ApplyTo(invocation);
var first = feature.ReturnValue;
arrangment.ApplyTo(invocation);
var second = feature.ReturnValue;
arrangment.ApplyTo(invocation);
var third = feature.ReturnValue;
arrangment.ApplyTo(invocation);
var fourth = feature.ReturnValue;
// Then
Assert.Equal(value1, first);
Assert.Equal(value2, second);
Assert.Equal(value3, third);
Assert.Equal(value3, fourth);
}
public void CanApplyWithNonMatchingSignatureReturnsFalseFunc()
{
// Given
var type = typeof(IFooFuncValueTypeParameterOut <int>);
var methodName = nameof(IFooFuncValueTypeParameterOut <int> .MethodWithOneParameter);
var valueTypeSignature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
type = typeof(IFooFuncReferenceTypeParameterOut <object>);
methodName = nameof(IFooFuncReferenceTypeParameterOut <object> .MethodWithOneParameter);
var referenceTypeSignature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var outParameterFeature = new ParameterOut(valueTypeSignature);
var invocation = new Invocation(valueTypeSignature, outParameterFeature);
var arrangment = new OutParameterArrangement <object?>(referenceTypeSignature, "first", new object());
// When
var canApply = arrangment.CanApplyTo(invocation);
// Then
Assert.False(canApply);
Assert.True(invocation.HasFeature <IParameterOut>());
var feature = invocation.GetFeature <IParameterOut>();
Assert.Single(feature.OutParameterCollection);
var parameter = feature.OutParameterCollection.Single();
Assert.Equal(default(int), parameter.Value);
}
public void EnsureTryApplyIsFalseForNonMatchingInvocationFunc()
{
// Given
var type = typeof(IFooFuncValueTypeParameterOut <int>);
var methodName = nameof(IFooFuncValueTypeParameterOut <int> .MethodWithOneParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var outParameterFeature = new ParameterOut(signature);
var invocation = new Invocation(signature, outParameterFeature);
var arrangment = new OutParameterArrangement <int>(signature, "WrongParameterName", 42);
// When
var wasApplied = arrangment.TryApplyTo(invocation);
// Then
Assert.False(wasApplied);
Assert.True(invocation.HasFeature <IParameterOut>());
var feature = invocation.GetFeature <IParameterOut>();
Assert.Single(feature.OutParameterCollection);
var parameter = feature.OutParameterCollection.Single();
Assert.Equal("first", parameter.Name);
Assert.Equal(typeof(int), parameter.Type);
Assert.Equal(default(int), parameter.Value);
}
public void ApplySequenceOfValueTypeReturnValuesGetterArrangement()
{
// Given
var signature = typeof(IFooValueTypeGetter <int>)
.GetProperty(nameof(IFooValueTypeGetter <int> .Getter)) ?? throw new InvalidOperationException();
var getter = signature.GetGetMethod() ?? throw new InvalidOperationException();
var propertyFeature = new PropertyInvocation(signature);
var returnValueFeature = new ReturnValueInvocation <int>();
var invocation = new Invocation(getter, propertyFeature, returnValueFeature);
var arrangment = new ReturnValueSequenceArrangement <int>(getter, new List <int>(new[] { 13, 42, 65 }));
// When
var feature = invocation.GetFeature <IReturnValue <int> >();
arrangment.ApplyTo(invocation);
var first = feature.ReturnValue;
arrangment.ApplyTo(invocation);
var second = feature.ReturnValue;
arrangment.ApplyTo(invocation);
var third = feature.ReturnValue;
arrangment.ApplyTo(invocation);
var fourth = feature.ReturnValue;
// Then
Assert.Equal(13, first);
Assert.Equal(42, second);
Assert.Equal(65, third);
Assert.Equal(65, fourth);
}
public void ApplyReferenceTypeOutParameterArrangementFunc()
{
// Given
var expectedValue = new object();
var type = typeof(IFooFuncReferenceTypeParameterOut <object>);
var methodName = nameof(IFooFuncReferenceTypeParameterOut <object> .MethodWithOneParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var outParameterFeature = new ParameterOut(signature);
var invocation = new Invocation(signature, outParameterFeature);
var arrangment = new OutParameterArrangement <object?>(signature, "first", expectedValue);
// When
arrangment.ApplyTo(invocation);
// Then
Assert.True(invocation.HasFeature <IParameterOut>());
var feature = invocation.GetFeature <IParameterOut>();
Assert.Single(feature.OutParameterCollection);
var parameter = feature.OutParameterCollection.Single();
Assert.Equal("first", parameter.Name);
Assert.Equal(typeof(object), parameter.Type);
Assert.Equal(expectedValue, parameter.Value);
}
public void ApplySequenceOfValueTypeReturnValuesArrangement()
{
// Given
var signature = typeof(IFooFuncValueTypeParameterless <int>)
.GetMethod(nameof(IFooFuncValueTypeParameterless <int> .MethodWithoutParameter)) ?? throw new InvalidOperationException();
var returnValueFeature = new ReturnValueInvocation <int>();
var invocation = new Invocation(signature, returnValueFeature);
var arrangment = new ReturnValueSequenceArrangement <int>(signature, new List <int>(new[] { 13, 42, 65 }));
// When
var feature = invocation.GetFeature <IReturnValue <int> >();
arrangment.ApplyTo(invocation);
var first = feature.ReturnValue;
arrangment.ApplyTo(invocation);
var second = feature.ReturnValue;
arrangment.ApplyTo(invocation);
var third = feature.ReturnValue;
arrangment.ApplyTo(invocation);
var fourth = feature.ReturnValue;
// Then
Assert.Equal(13, first);
Assert.Equal(42, second);
Assert.Equal(65, third);
Assert.Equal(65, fourth);
}
public void CanApplySequenceWithMatchingSignatureReturnsTrueFunc()
{
// Given
var type = typeof(IFooFuncValueTypeParameterOut <int>);
var methodName = nameof(IFooFuncValueTypeParameterOut <int> .MethodWithOneParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var outParameterFeature = new ParameterOut(signature);
var invocation = new Invocation(signature, outParameterFeature);
var arrangment = new OutParameterSequenceArrangement <int>(signature, "first", new List <int> {
42
});
// When
var canApply = arrangment.CanApplyTo(invocation);
// Then
Assert.True(canApply);
Assert.True(invocation.HasFeature <IParameterOut>());
var feature = invocation.GetFeature <IParameterOut>();
Assert.Single(feature.OutParameterCollection);
var parameter = feature.OutParameterCollection.Single();
Assert.Equal(default(int), parameter.Value);
}
public void ApplyAsyncValueTypeTaskReturnValueArrangement()
{
// Given
var signature = typeof(IFooGenericTaskValueTypeParameterless)
.GetMethod(nameof(IFooGenericTaskValueTypeParameterless.MethodWithoutParameterAsync)) ?? throw new InvalidOperationException();
var asyncFeature = new AsyncGenericTaskInvocation <int>();
var invocation = new Invocation(signature, asyncFeature);
var arrangment = new ReturnValueArrangement <Task <int> >(signature, Task.FromResult(42));
// When
arrangment.ApplyTo(invocation);
// Then
Assert.True(invocation.HasFeature <IAsyncInvocation <Task <int> > >());
var feature = invocation.GetFeature <IAsyncInvocation <Task <int> > >();
Assert.IsAssignableFrom <Task <int> >(feature.AsyncReturnValue);
Assert.True(invocation.HasFeature <IReturnValue <int> >());
var returnValueFeature = invocation.GetFeature <IReturnValue <int> >();
Assert.Equal(42, returnValueFeature.ReturnValue);
}
public void ApplyAsyncSequenceOfReferenceTypeTaskReturnValuesArrangement()
{
// Given
var value1 = new object();
var value2 = new object();
var value3 = new object();
var signature = typeof(IFooGenericTaskReferenceTypeParameterless)
.GetMethod(nameof(IFooGenericTaskReferenceTypeParameterless.MethodWithoutParameterAsync)) ?? throw new InvalidOperationException();
var asyncFeature = new AsyncGenericTaskInvocation <object?>();
var invocation = new Invocation(signature, asyncFeature);
var arrangment = new ReturnValueSequenceArrangement <Task <object?> >(signature, new List <Task <object?> >(new[]
{
Task.FromResult <object?>(value1),
Task.FromResult <object?>(value2),
Task.FromResult <object?>(value3)
}));
// When
var feature = invocation.GetFeature <IAsyncInvocation <Task <object?> > >();
arrangment.ApplyTo(invocation);
var first = feature.AsyncReturnValue;
arrangment.ApplyTo(invocation);
var second = feature.AsyncReturnValue;
arrangment.ApplyTo(invocation);
var third = feature.AsyncReturnValue;
arrangment.ApplyTo(invocation);
var fourth = feature.AsyncReturnValue;
// Then
Assert.NotNull(first);
Assert.IsAssignableFrom <Task <object?> >(first);
Assert.Equal(value1, first.Result);
Assert.NotNull(second);
Assert.IsAssignableFrom <Task <object?> >(second);
Assert.Equal(value2, second.Result);
Assert.NotNull(third);
Assert.IsAssignableFrom <Task <object?> >(third);
Assert.Equal(value3, third.Result);
Assert.NotNull(fourth);
Assert.IsAssignableFrom <Task <object?> >(fourth);
Assert.Equal(value3, fourth.Result);
}
public void ApplyValueTypeReturnValueArrangement()
{
// Given
var signature = typeof(IFooFuncValueTypeParameterless <int>)
.GetMethod(nameof(IFooFuncValueTypeParameterless <int> .MethodWithoutParameter)) ?? throw new InvalidOperationException();
var returnValueFeature = new ReturnValueInvocation <int>();
var invocation = new Invocation(signature, returnValueFeature);
var arrangment = new ReturnValueArrangement <int>(signature, 42);
// When
arrangment.ApplyTo(invocation);
// Then
Assert.True(invocation.HasFeature <IReturnValue <int> >());
var feature = invocation.GetFeature <IReturnValue <int> >();
Assert.Equal(42, feature.ReturnValue);
}
public void EnsureNoArrangentIsAppliedToNonMatchingInvocation()
{
// Given
var valueTypeSignature = typeof(IFooFuncValueTypeParameterless <int>)
.GetMethod(nameof(IFooFuncValueTypeParameterless <int> .MethodWithoutParameter)) ?? throw new InvalidOperationException();
var referenceTypeSignature = typeof(IFooFuncReferenceTypeParameterless <object>)
.GetMethod(nameof(IFooFuncReferenceTypeParameterless <object> .MethodWithoutParameter)) ?? throw new InvalidOperationException();
var returnValueFeature = new ReturnValueInvocation <int>();
var invocation = new Invocation(referenceTypeSignature, returnValueFeature);
var arrangment = new ReturnValueSequenceArrangement <int>(valueTypeSignature, new List <int>(new[] { 42 }));
// When
arrangment.ApplyTo(invocation);
// Then
var feature = invocation.GetFeature <IReturnValue <int> >();
Assert.Equal(default, feature.ReturnValue);
public void ApplyValueTypeGetterReturnValueArrangement()
{
// Given
var signature = typeof(IFooValueTypeGetter <int>)
.GetProperty(nameof(IFooValueTypeGetter <int> .Getter)) ?? throw new InvalidOperationException();
var getter = signature.GetGetMethod() ?? throw new InvalidOperationException();
var propertyFeature = new PropertyInvocation(signature);
var returnValueFeature = new ReturnValueInvocation <int>();
var invocation = new Invocation(getter, propertyFeature, returnValueFeature);
var arrangment = new ReturnValueArrangement <int>(getter, 42);
// When
arrangment.ApplyTo(invocation);
// Then
Assert.True(invocation.HasFeature <IReturnValue <int> >());
var feature = invocation.GetFeature <IReturnValue <int> >();
Assert.Equal(42, feature.ReturnValue);
}
public void EnsureNoArrangentIsAppliedToNonMatchingParameterInvocationFunc()
{
// Given
var type = typeof(IFooFuncValueTypeParameterRef <int>);
var methodName = nameof(IFooFuncValueTypeParameterRef <int> .MethodWithOneParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var refParameterFeature = new ParameterRef(signature, new object?[] { 13 });
var invocation = new Invocation(signature, refParameterFeature);
var arrangment = new RefParameterArrangement <int>(signature, "WrongParameterName", 42);
// When
arrangment.ApplyTo(invocation);
// Then
Assert.True(invocation.HasFeature <IParameterRef>());
var feature = invocation.GetFeature <IParameterRef>();
Assert.Single(feature.RefParameterCollection);
var parameter = feature.RefParameterCollection.Single();
Assert.Equal(13, parameter.Value);
}
public void ApplyAsyncSequenceOfValueTypeReturnValuesArrangement()
{
// Given
var signature = typeof(IFooGenericTaskValueTypeParameterless)
.GetMethod(nameof(IFooGenericTaskValueTypeParameterless.MethodWithoutParameterAsync)) ?? throw new InvalidOperationException();
var asyncFeature = new AsyncGenericTaskInvocation <int>();
var invocation = new Invocation(signature, asyncFeature);
var arrangment = new ReturnValueSequenceArrangement <int>(signature, new List <int>(new[] { 13, 42, 65 }));
// When
var feature = invocation.GetFeature <IAsyncInvocation <Task <int> > >();
arrangment.ApplyTo(invocation);
var first = feature.AsyncReturnValue;
arrangment.ApplyTo(invocation);
var second = feature.AsyncReturnValue;
arrangment.ApplyTo(invocation);
var third = feature.AsyncReturnValue;
arrangment.ApplyTo(invocation);
var fourth = feature.AsyncReturnValue;
// Then
Assert.NotNull(first);
Assert.IsAssignableFrom <Task <int> >(first);
Assert.Equal(13, first.Result);
Assert.NotNull(second);
Assert.IsAssignableFrom <Task <int> >(second);
Assert.Equal(42, second.Result);
Assert.NotNull(third);
Assert.IsAssignableFrom <Task <int> >(third);
Assert.Equal(65, third.Result);
Assert.NotNull(fourth);
Assert.IsAssignableFrom <Task <int> >(fourth);
Assert.Equal(65, fourth.Result);
}
public void TryToApplyOnlyMatchingArrangements()
{
// Given
var signature = typeof(IFooFuncValueTypeParameterless <int>)
.GetMethod(nameof(IFooFuncValueTypeParameterless <int> .MethodWithoutParameter)) ?? throw new InvalidOperationException();
var otherSignature = typeof(IFooFuncValueTypeParameterIn <int>)
.GetMethod(nameof(IFooFuncValueTypeParameterIn <int> .MethodWithOneParameter)) ?? throw new InvalidOperationException();
var returnValueFeature = new ReturnValueInvocation <int>();
var invocation = new Invocation(signature, returnValueFeature);
var arrangment = new ReturnValueArrangement <int>(signature, 42);
var otherArrangment = new ReturnValueArrangement <int>(otherSignature, 13);
var arrangmentCollection = new ArrangementCollection(arrangment, otherArrangment);
// When
var hasAppliedArrangment = arrangmentCollection.TryApplyTo(invocation);
// Then
Assert.True(hasAppliedArrangment);
Assert.True(invocation.HasFeature <IReturnValue <int> >());
var feature = invocation.GetFeature <IReturnValue <int> >();
Assert.Equal(42, feature.ReturnValue);
}
public void CanApplyWithNonMatchingParameterReturnsFalse()
{
// Given
var type = typeof(IFooActionValueTypeParameterOut <int>);
var methodName = nameof(IFooActionValueTypeParameterOut <int> .MethodWithOneParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var outParameterFeature = new ParameterOut(signature);
var invocation = new Invocation(signature, outParameterFeature);
var arrangment = new OutParameterArrangement <int>(signature, "WrongParameterName", 42);
// When
var canApply = arrangment.CanApplyTo(invocation);
// Then
Assert.False(canApply);
Assert.True(invocation.HasFeature <IParameterOut>());
var feature = invocation.GetFeature <IParameterOut>();
Assert.Single(feature.OutParameterCollection);
var parameter = feature.OutParameterCollection.Single();
Assert.Equal(default(int), parameter.Value);
}
public void CanApplyWithMatchingSignatureReturnsTrueFunc()
{
// Given
var type = typeof(IFooFuncValueTypeParameterRef <int>);
var methodName = nameof(IFooFuncValueTypeParameterRef <int> .MethodWithOneParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var refParameterFeature = new ParameterRef(signature, new object?[] { 13 });
var invocation = new Invocation(signature, refParameterFeature);
var arrangment = new RefParameterArrangement <int>(signature, "first", 42);
// When
var canApply = arrangment.CanApplyTo(invocation);
// Then
Assert.True(canApply);
Assert.True(invocation.HasFeature <IParameterRef>());
var feature = invocation.GetFeature <IParameterRef>();
Assert.Single(feature.RefParameterCollection);
var parameter = feature.RefParameterCollection.Single();
Assert.Equal(13, parameter.Value);
}
public void ApplySequenceOfReferenceTypeOutParametersArrangement()
{
// Given
var value1 = new object();
var value2 = new object();
var value3 = new object();
var type = typeof(IFooActionReferenceTypeParameterOut <object>);
var methodName = nameof(IFooActionReferenceTypeParameterOut <object> .MethodWithOneParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var outParameterFeature = new ParameterOut(signature);
var invocation = new Invocation(signature, outParameterFeature);
var arrangment = new OutParameterSequenceArrangement <object?>(
signature, "first", new List <object?> {
value1, value2, value3
});
// When
var feature = invocation.GetFeature <IParameterOut>();
arrangment.ApplyTo(invocation);
var first = feature.OutParameterCollection.First().Value;
arrangment.ApplyTo(invocation);
var second = feature.OutParameterCollection.First().Value;
arrangment.ApplyTo(invocation);
var third = feature.OutParameterCollection.First().Value;
arrangment.ApplyTo(invocation);
var fourth = feature.OutParameterCollection.First().Value;
// Then
Assert.Equal(value1, first);
Assert.Equal(value2, second);
Assert.Equal(value3, third);
Assert.Equal(value3, fourth);
}
public void TryApplySequenceOfReferenceTypeRefParametersArrangementFunc()
{
// Given
var value1 = new object();
var value2 = new object();
var value3 = new object();
var type = typeof(IFooFuncReferenceTypeParameterRef <object>);
var methodName = nameof(IFooFuncReferenceTypeParameterRef <object> .MethodWithOneParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var refParameterFeature = new ParameterRef(signature, new object[] { 9 });
var invocation = new Invocation(signature, refParameterFeature);
var arrangment = new RefParameterSequenceArrangement <object?>(
signature, "first", new List <object?> {
value1, value2, value3
});
// When
var feature = invocation.GetFeature <IParameterRef>();
var wasFirstApplied = arrangment.TryApplyTo(invocation);
var first = feature.RefParameterCollection.First().Value;
var wasSecondApplied = arrangment.TryApplyTo(invocation);
var second = feature.RefParameterCollection.First().Value;
var wasThirdApplied = arrangment.TryApplyTo(invocation);
var third = feature.RefParameterCollection.First().Value;
var wasFourthApplied = arrangment.TryApplyTo(invocation);
var fourth = feature.RefParameterCollection.First().Value;
// Then
Assert.True(wasFirstApplied);
Assert.Equal(value1, first);
Assert.True(wasSecondApplied);
Assert.Equal(value2, second);
Assert.True(wasThirdApplied);
Assert.Equal(value3, third);
Assert.True(wasFourthApplied);
Assert.Equal(value3, fourth);
}
public void EnsureNoArrangentIsAppliedToNonMatchingParameterInvocationFunc()
{
// Given
var type = typeof(IFooFuncValueTypeParameterOut <int>);
var methodName = nameof(IFooFuncValueTypeParameterOut <int> .MethodWithOneParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var outParameterFeature = new ParameterOut(signature);
var invocation = new Invocation(signature, outParameterFeature);
var arrangment = new OutParameterSequenceArrangement <int>(signature, "WrongParameterName", new List <int> {
13, 42, 65
});
// When
arrangment.ApplyTo(invocation);
// Then
Assert.True(invocation.HasFeature <IParameterOut>());
var feature = invocation.GetFeature <IParameterOut>();
Assert.Single(feature.OutParameterCollection);
var parameter = feature.OutParameterCollection.Single();
Assert.Equal(default(int), parameter.Value);
}
public void ApplyValueTypeRefParameterArrangement()
{
// Given
var type = typeof(IFooActionValueTypeParameterRef <int>);
var methodName = nameof(IFooActionValueTypeParameterRef <int> .MethodWithOneParameter);
var signature = type.GetMethod(methodName) ?? throw new MethodInfoException(type, methodName);
var refParameterFeature = new ParameterRef(signature, new object?[] { 13 });
var invocation = new Invocation(signature, refParameterFeature);
var arrangment = new RefParameterArrangement <int>(signature, "first", 42);
// When
arrangment.ApplyTo(invocation);
// Then
Assert.True(invocation.HasFeature <IParameterRef>());
var feature = invocation.GetFeature <IParameterRef>();
Assert.Single(feature.RefParameterCollection);
var parameter = feature.RefParameterCollection.Single();
Assert.Equal("first", parameter.Name);
Assert.Equal(typeof(int), parameter.Type);
Assert.Equal(42, parameter.Value);
}
