public virtual void PickerPeerOnlySupportsCorrectPatterns()
        {
            TimePickerPopup instance           = TimePickerPopupInstance;
            TimePickerPopupAutomationPeer peer = null;

            TestAsync(
                instance,
                () => peer = (TimePickerPopupAutomationPeer)FrameworkElementAutomationPeer.CreatePeerForElement(instance),
                () =>
            {
                int index = 0;
                while (Enum.IsDefined(typeof(PatternInterface), index))
                {
                    PatternInterface currentInterface = (PatternInterface)Enum.ToObject(typeof(PatternInterface), index);
                    object implementation             = peer.GetPattern(currentInterface);
                    if (ExpectedPatterns.Contains(currentInterface))
                    {
                        Assert.IsNotNull(implementation);
                    }
                    else
                    {
                        Assert.IsNull(implementation);
                    }
                    index++;
                }
            });
        }
        public virtual void CreateTimePickerPopupPeer()
        {
            TimePickerPopup tpp = TimePickerPopupInstance;
            TimePickerPopupAutomationPeer peer = GetTimePickerPopupAutomationPeer(tpp);

            Assert.IsNotNull(peer);
        }
        public virtual void TimePickerPopupCreatesCorrectAutomationPeer()
        {
            TimePickerPopup tpp = TimePickerPopupInstance;
            TimePickerPopupAutomationPeer peer = null;

            TestAsync(
                tpp,
                () => peer = FrameworkElementAutomationPeer.CreatePeerForElement(tpp) as TimePickerPopupAutomationPeer,
                () => Assert.IsNotNull(peer, "TimePickerPopup peer should not be null!"),
                () => Assert.AreEqual(tpp, peer.Owner, "TimePickerPopup should be owner of the peer!"));
        }
        public virtual void ShouldCorrelateReadOnlyToIsEnabledInAutomationPeer()
        {
            TimePickerPopup item = TimePickerPopupInstance;

            item.Value = new DateTime(1900, 1, 1, 3, 45, 12);
            TimePickerPopupAutomationPeer peer = null;
            IValueProvider provider            = null;

            TestAsync(
                item,
                () => peer     = (TimePickerPopupAutomationPeer)FrameworkElementAutomationPeer.CreatePeerForElement(item),
                () => provider = (IValueProvider)peer.GetPattern(PatternInterface.Value),
                () => Assert.IsFalse(provider.IsReadOnly),
                () => item.IsEnabled = false,
                () => Assert.IsTrue(provider.IsReadOnly));
        }
        public virtual void ShouldBeAbleToGetValueThroughAutomationPeer()
        {
            TimePickerPopup item = TimePickerPopupInstance;

            item.Culture = new CultureInfo("nl-NL");
            item.Format  = new CustomTimeFormat("HH:mm:ss");
            item.Value   = new DateTime(1900, 1, 1, 3, 45, 12);
            TimePickerPopupAutomationPeer peer = null;
            IValueProvider provider            = null;

            TestAsync(
                item,
                () => peer     = (TimePickerPopupAutomationPeer)FrameworkElementAutomationPeer.CreatePeerForElement(item),
                () => provider = (IValueProvider)peer.GetPattern(PatternInterface.Value),
                () => Assert.AreEqual(provider.Value, "03:45:12"));
        }
        public virtual void ShouldBeAbleToSetValueThroughAutomationPeer()
        {
            TimePickerPopup item = TimePickerPopupInstance;

            item.Culture = new CultureInfo("nl-NL");
            item.Format  = new CustomTimeFormat("HH:mm:ss");
            TimePickerPopupAutomationPeer peer = null;
            IValueProvider provider            = null;

            TestAsync(
                item,
                () => peer     = (TimePickerPopupAutomationPeer)FrameworkElementAutomationPeer.CreatePeerForElement(item),
                () => provider = (IValueProvider)peer.GetPattern(PatternInterface.Value),
                () => provider.SetValue("03:30:00"),     // take care to set a time that is not snapped
                () => Assert.AreEqual(item.Value.Value.TimeOfDay, new DateTime(1900, 1, 1, 3, 30, 00).TimeOfDay));
        }
        /// <summary>
        /// ValueProperty property changed handler.
        /// </summary>
        /// <param name="d">UpDownBase whose Value changed.</param>
        /// <param name="e">Event arguments.</param>
        private static void OnValuePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            TimePickerPopup source = (TimePickerPopup)d;

            // Ignore the change if requested
            if (source._ignoreValueChange)
            {
                // we do want to raise the event, but won't react to anything.
                source.OnValueChanged(new RoutedPropertyChangedEventArgs <DateTime?>(e.OldValue as DateTime?, e.NewValue as DateTime?));
                return;
            }

            DateTime?oldValue = (DateTime?)e.OldValue;
            DateTime?newValue = (DateTime?)e.NewValue;

            // simulate pre and post events
            // The Value has already been changed when this function is called.
            // So if user's chaning event handler check Value, it will be the changed value.
            // This is confusing, because we are simulating pre event on the platform that doesn't natively support it.
            RoutedPropertyChangingEventArgs <DateTime?> changingArgs = new RoutedPropertyChangingEventArgs <DateTime?>(e.Property, oldValue, newValue, true);

            source.OnValueChanging(changingArgs);

            // workaround the class hierarchy for value coercion
            if (changingArgs.InCoercion)
            {
            }
            else if (!changingArgs.Cancel)
            {
                newValue = changingArgs.NewValue;
                RoutedPropertyChangedEventArgs <DateTime?> changedArgs = new RoutedPropertyChangedEventArgs <DateTime?>(oldValue, newValue);
                source.OnValueChanged(changedArgs);

                TimePickerPopupAutomationPeer peer = FrameworkElementAutomationPeer.FromElement(source) as TimePickerPopupAutomationPeer;
                if (peer != null)
                {
                    peer.RaiseValueAutomationEvent(oldValue, newValue);
                }
            }
            else
            {
                // revert back to old value if an event handler canceled the changing event.
                source._ignoreValueChange = true;
                source.Value = oldValue;
                source._ignoreValueChange = false;
            }
        }