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 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 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 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 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 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 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 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 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 ReturnValueArrangement <int>(valueTypeSignature, 42); // When arrangment.ApplyTo(invocation); // Then Assert.True(invocation.HasFeature <IReturnValue <int> >()); 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 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 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 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); }