/// <summary>
        /// Specifies another verification.
        /// </summary>
        /// <param name="assertionTracker">The assertion tracker.</param>
        /// <returns>
        /// The assertion tracker.
        /// </returns>
        public static AssertionTracker And(
            [ValidatedNotNull] this AssertionTracker assertionTracker)
        {
            assertionTracker.ThrowImproperUseOfFrameworkIfDetected(AssertionTrackerShould.Exist, AssertionTrackerShould.BeMusted, AssertionTrackerShould.BeVerifiedAtLeastOnce);

            return(assertionTracker);
        }
        /// <summary>
        /// Specifies that the verifications should be applied
        /// to the elements of the <see cref="IEnumerable"/> subject.
        /// </summary>
        /// <param name="assertionTracker">The assertion tracker.</param>
        /// <returns>
        /// The assertion tracker in a state where verifications will be
        /// applied to the elements of the <see cref="IEnumerable"/> subject.
        /// </returns>
        public static AssertionTracker Each(
            [ValidatedNotNull] this AssertionTracker assertionTracker)
        {
            assertionTracker.ThrowImproperUseOfFrameworkIfDetected(AssertionTrackerShould.Exist, AssertionTrackerShould.BeMusted, AssertionTrackerShould.NotBeEached);

            assertionTracker.Actions |= Actions.Eached;

            return(assertionTracker);
        }
Esempio n. 3
0
#pragma warning disable SA1201

        private static void ExecuteVerification(
            this AssertionTracker assertionTracker,
            Verification verification)
        {
            assertionTracker.ThrowImproperUseOfFrameworkIfDetected(AssertionTrackerShould.Exist, AssertionTrackerShould.BeMusted);

            var hasBeenEached = assertionTracker.Actions.HasFlag(Actions.Eached);

            if (hasBeenEached)
            {
                // check that the subject is an IEnumerable and not null
                if (!assertionTracker.Actions.HasFlag(Actions.VerifiedAtLeastOnce))
                {
                    var eachVerification = new Verification
                    {
                        Name = nameof(WorkflowExtensions.Each),
                    };

                    var eachVerifiableItem = new VerifiableItem
                    {
                        ItemValue = assertionTracker.SubjectValue,
                        ItemType  = assertionTracker.SubjectType,
                        ItemIsElementInEnumerable = false,
                    };

                    ThrowIfNotAssignableToType(eachVerification, eachVerifiableItem, MustBeEnumerableTypeValidations.Single());

                    NotBeNullInternal(assertionTracker, eachVerification, eachVerifiableItem);
                }

                var valueAsEnumerable = (IEnumerable)assertionTracker.SubjectValue;

                var enumerableElementType = assertionTracker.SubjectType.GetClosedEnumerableElementType();

                var verifiableItem = new VerifiableItem
                {
                    ItemIsElementInEnumerable = true,
                    ItemType = enumerableElementType,
                };

                foreach (var typeValidation in verification.TypeValidations ?? new TypeValidation[] { })
                {
                    typeValidation.Handler(verification, verifiableItem, typeValidation);
                }

                foreach (var element in valueAsEnumerable)
                {
                    verifiableItem.ItemValue = element;

                    verification.Handler(assertionTracker, verification, verifiableItem);
                }
            }
            else
            {
                var verifiableItem = new VerifiableItem
                {
                    ItemIsElementInEnumerable = false,
                    ItemValue = assertionTracker.SubjectValue,
                    ItemType  = assertionTracker.SubjectType,
                };

                foreach (var typeValidation in verification.TypeValidations ?? new TypeValidation[] { })
                {
                    typeValidation.Handler(verification, verifiableItem, typeValidation);
                }

                verification.Handler(assertionTracker, verification, verifiableItem);
            }

            assertionTracker.Actions |= Actions.VerifiedAtLeastOnce;
        }