Пример #1
0
        /// <summary>Asserts that exactly one remove stream event was received and no insert stream events, resets the listener clearing all state and returns the received event. </summary>
        /// <returns>single remove-stream event</returns>
        public object AssertOneGetOldAndReset()
        {
            ScopeTestHelper.AssertTrue("Listener invocation not received but expected", _isInvoked);

            ScopeTestHelper.AssertEquals("Mismatch in the number of invocations", 1, _newDataList.Count);
            ScopeTestHelper.AssertEquals("Mismatch in the number of invocations", 1, _oldDataList.Count);

            if (_lastOldData == null)
            {
                ScopeTestHelper.Fail("No old-data events received");
            }
            ScopeTestHelper.AssertEquals("Mismatch in the number of old-data events", 1, _lastOldData.Length);
            ScopeTestHelper.AssertNull("Expected no new-data events", _lastNewData);

            object lastNew = _lastOldData[0];

            Reset();
            return(lastNew);
        }
        private static void AssertConsistencyRecursive(EventType eventType, ISet<EventType> alreadySeenTypes)
        {
            if (alreadySeenTypes.Contains(eventType))
            {
                return;
            }
            alreadySeenTypes.Add(eventType);

            AssertConsistencyProperties(eventType);

            // test fragments
            foreach (EventPropertyDescriptor descriptor in eventType.PropertyDescriptors)
            {
                string failedMessage = "failed assertion for property '" + descriptor.PropertyName + "' ";
                if (!descriptor.IsFragment)
                {
                    ScopeTestHelper.AssertNull(failedMessage, eventType.GetFragmentType(descriptor.PropertyName));
                    continue;
                }

                FragmentEventType fragment = eventType.GetFragmentType(descriptor.PropertyName);
                if (!descriptor.RequiresIndex)
                {
                    ScopeTestHelper.AssertNotNull(failedMessage, fragment);
                    if (fragment.IsIndexed)
                    {
                        ScopeTestHelper.AssertTrue(descriptor.IsIndexed);
                    }
                    AssertConsistencyRecursive(fragment.FragmentType, alreadySeenTypes);
                }
                else
                {
                    fragment = eventType.GetFragmentType(descriptor.PropertyName + "[0]");
                    ScopeTestHelper.AssertNotNull(failedMessage, fragment);
                    ScopeTestHelper.AssertTrue(descriptor.IsIndexed);
                    AssertConsistencyRecursive(fragment.FragmentType, alreadySeenTypes);
                }
            }
        }
Пример #3
0
        private static void AssertConsistencyRecursive(
            EventBean eventBean,
            ISet<EventType> alreadySeenTypes)
        {
            AssertConsistencyRecursive(eventBean.EventType, alreadySeenTypes);

            var properties = eventBean.EventType.PropertyDescriptors;
            for (var i = 0; i < properties.Count; i++) {
                var failedMessage = "failed assertion for property '" + properties[i].PropertyName + "' ";
                var propertyName = properties[i].PropertyName;

                // assert getter
                if (!properties[i].IsRequiresIndex && !properties[i].IsRequiresMapKey) {
                    var getter = eventBean.EventType.GetGetter(propertyName);
                    var resultGetter = getter.Get(eventBean);
                    var resultGet = eventBean.Get(propertyName);

                    if (resultGetter == null && resultGet == null) {
                        // fine
                    }
                    else if (resultGet is XmlNodeList) {
                        ScopeTestHelper.AssertEquals(
                            failedMessage,
                            ((XmlNodeList) resultGet).Count,
                            ((XmlNodeList) resultGetter).Count);
                    }
                    else if (resultGet.GetType().IsArray) {
                        ScopeTestHelper.AssertEquals(
                            failedMessage,
                            ((Array) resultGet).Length,
                            ((Array) resultGetter).Length);
                    }
                    else {
                        ScopeTestHelper.AssertEquals(failedMessage, resultGet, resultGetter);
                    }

                    if (resultGet != null) {
                        if (resultGet is EventBean[] || resultGet is EventBean) {
                            ScopeTestHelper.AssertTrue(properties[i].IsFragment);
                        }
                        else {
                            var resultType = resultGet.GetType();
                            var propertyType = properties[i].PropertyType.GetBoxedType();
                            if ((resultType != propertyType) &&
                                !TypeHelper.IsSubclassOrImplementsInterface(resultType, propertyType)) {
                                ScopeTestHelper.Fail(failedMessage);
                            }
                        }
                    }
                }

                // fragment
                if (!properties[i].IsFragment) {
                    ScopeTestHelper.AssertNull(failedMessage, eventBean.GetFragment(propertyName));
                    continue;
                }

                var fragmentType = eventBean.EventType.GetFragmentType(propertyName);
                ScopeTestHelper.AssertNotNull(failedMessage, fragmentType);

                // fragment can be null
                var fragment = eventBean.GetFragment(propertyName);
                if (fragment == null) {
                    return;
                }

                if (!fragmentType.IsIndexed) {
                    ScopeTestHelper.AssertTrue(failedMessage, fragment is EventBean);
                    var fragmentEvent = (EventBean) fragment;
                    AssertConsistencyRecursive(fragmentEvent, alreadySeenTypes);
                }
                else {
                    ScopeTestHelper.AssertTrue(failedMessage, fragment is EventBean[]);
                    var events = (EventBean[]) fragment;
                    ScopeTestHelper.AssertTrue(failedMessage, events.Length > 0);
                    foreach (var theEvent in events) {
                        AssertConsistencyRecursive(theEvent, alreadySeenTypes);
                    }
                }
            }
        }
        private static void AssertConsistencyRecusive(EventBean eventBean, ISet<EventType> alreadySeenTypes)
        {
            AssertConsistencyRecursive(eventBean.EventType, alreadySeenTypes);

            IList<EventPropertyDescriptor> properties = eventBean.EventType.PropertyDescriptors;
            for (int i = 0; i < properties.Count; i++)
            {
                string failedMessage = "failed assertion for property '" + properties[i].PropertyName + "' ";
                string propertyName = properties[i].PropertyName;

                // assert getter
                if ((!properties[i].RequiresIndex) && (!properties[i].RequiresMapKey))
                {
                    EventPropertyGetter getter = eventBean.EventType.GetGetter(propertyName);
                    object resultGetter = getter.Get(eventBean);
                    object resultGet = eventBean.Get(propertyName);

                    if ((resultGetter == null) && (resultGet == null))
                    {
                        // fine
                    }
                    else if (resultGet is XmlNodeList)
                    {
                        ScopeTestHelper.AssertEquals(
                            failedMessage, 
                            ((XmlNodeList) resultGet).Count, 
                            ((XmlNodeList) resultGetter).Count);
                    }
                    else if (resultGet is Array)
                    {
                        ScopeTestHelper.AssertEquals(
                            failedMessage,
                            ((Array) resultGet).Length,
                            ((Array) resultGetter).Length);
                    }
                    else
                    {
                        ScopeTestHelper.AssertEquals(failedMessage, resultGet, resultGetter);
                    }

                    if (resultGet != null)
                    {
                        if (resultGet is EventBean[] || resultGet is EventBean)
                        {
                            ScopeTestHelper.AssertTrue(properties[i].IsFragment);
                        }
                        else
                        {
                            ScopeTestHelper.AssertTrue(
                                failedMessage,
                                TypeHelper.IsSubclassOrImplementsInterface(
                                    resultGet.GetType(),
                                    properties[i].PropertyType.GetBoxedType()));
                        }
                    }
                }

                // fragment
                if (!properties[i].IsFragment)
                {
                    ScopeTestHelper.AssertNull(failedMessage, eventBean.GetFragment(propertyName));
                    continue;
                }

                object fragment = eventBean.GetFragment(propertyName);
                ScopeTestHelper.AssertNotNull(failedMessage, fragment);

                FragmentEventType fragmentType = eventBean.EventType.GetFragmentType(propertyName);
                ScopeTestHelper.AssertNotNull(failedMessage, fragmentType);

                if (!fragmentType.IsIndexed)
                {
                    ScopeTestHelper.AssertTrue(failedMessage, fragment is EventBean);
                    var fragmentEvent = (EventBean) fragment;
                    AssertConsistencyRecusive(fragmentEvent, alreadySeenTypes);
                }
                else
                {
                    ScopeTestHelper.AssertTrue(failedMessage, fragment is EventBean[]);
                    var events = (EventBean[]) fragment;
                    ScopeTestHelper.AssertTrue(failedMessage, events.Length > 0);
                    foreach (EventBean theEvent in events)
                    {
                        AssertConsistencyRecusive(theEvent, alreadySeenTypes);
                    }
                }
            }
        }