示例#1
0
        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);
        }
示例#2
0
        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);
        }
示例#3
0
        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 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);
        }
示例#5
0
        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 CheckIfAMatchingArrangmentExists()
        {
            // 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 hasMatchingArrangment = arrangmentCollection.CanApplyAtLeasOneArrangmentTo(invocation);

            // Then
            Assert.True(hasMatchingArrangment);
        }
        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 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);
        }