Example #1
0
        static ConstantExpressionRepresentationTTest()
        {
            ConstructorArgumentValidationTestScenarios
            .RemoveAllScenarios()
            .AddScenario(() =>
                         new ConstructorArgumentValidationTestScenario <ConstantExpressionRepresentation <Version> >
            {
                Name             = "constructor should throw ArgumentNullException when parameter 'type' is null scenario",
                ConstructionFunc = () =>
                {
                    var referenceObject = A.Dummy <ConstantExpressionRepresentation <Version> >();

                    var result = new ConstantExpressionRepresentation <Version>(
                        null,
                        referenceObject.NodeType,
                        referenceObject.Value);

                    return(result);
                },
                ExpectedExceptionType            = typeof(ArgumentNullException),
                ExpectedExceptionMessageContains = new[] { "type" },
            });
        }
Example #2
0
        public RepresentationSystemDummyFactory()
        {
            AutoFixtureBackedDummyFactory.AddDummyCreator(
                () =>
            {
                // TypeDummyFactory will return a real, loaded type.
                var result = A.Dummy <Type>().ToRepresentation();

                return(result);
            });

            // prevent infinite recursion for some derivatives
            AutoFixtureBackedDummyFactory.AddDummyCreator(
                () =>
            {
                ExpressionRepresentationBase result;

                var randomNumber = ThreadSafeRandom.Next(0, 3);

                if (randomNumber == 0)
                {
                    result = new ConstantExpressionRepresentation <string>(
                        A.Dummy <TypeRepresentation>(),
                        A.Dummy <ExpressionType>(),
                        A.Dummy <string>());
                }
                else if (randomNumber == 1)
                {
                    // this will ensure that type is being properly registered in serialization
                    // because BSON serializes DateTime with 3 f's precision, whereas our
                    // serializer uses 7 f's, so roundtrip serialization will fail if our serializer
                    // is not registered.
                    result = new ConstantExpressionRepresentation <DateTime>(
                        A.Dummy <TypeRepresentation>(),
                        A.Dummy <ExpressionType>(),
                        A.Dummy <DateTime>());
                }
                else
                {
                    result = new ParameterExpressionRepresentation(
                        A.Dummy <TypeRepresentation>(),
                        A.Dummy <string>());
                }

                return(result);
            });

            // prevent infinite recursion for some derivatives
            AutoFixtureBackedDummyFactory.AddDummyCreator(
                () =>
            {
                MemberBindingRepresentationBase result;

                var randomNumber = ThreadSafeRandom.Next(0, 2);

                if (randomNumber == 0)
                {
                    result = new MemberAssignmentRepresentation(
                        A.Dummy <TypeRepresentation>(),
                        A.Dummy <MemberInfoRepresentation>(),
                        A.Dummy <ExpressionRepresentationBase>());
                }
                else
                {
                    result = new MemberListBindingRepresentation(
                        A.Dummy <TypeRepresentation>(),
                        A.Dummy <MemberInfoRepresentation>(),
                        A.Dummy <IReadOnlyList <ElementInitRepresentation> >());
                }

                return(result);
            });
        }