Example #1
0
 public CalendarCellAccessibleObject(MonthCalendarAccessibleObject calendarAccessibleObject, int calendarIndex, AccessibleObject parentAccessibleObject, int rowIndex, int columnIndex, string name)
     : base(calendarAccessibleObject, calendarIndex, CalendarChildType.CalendarCell, parentAccessibleObject, rowIndex * columnIndex)
 {
     _rowIndex    = rowIndex;
     _columnIndex = columnIndex;
     _name        = name;
 }
Example #2
0
 public CalendarCellAccessibleObject(CalendarRowAccessibleObject calendarRowAccessibleObject,
                                     CalendarBodyAccessibleObject calendarBodyAccessibleObject,
                                     MonthCalendarAccessibleObject monthCalendarAccessibleObject,
                                     int calendarIndex, int rowIndex, int columnIndex)
     : base(monthCalendarAccessibleObject)
 {
     _calendarRowAccessibleObject   = calendarRowAccessibleObject;
     _calendarBodyAccessibleObject  = calendarBodyAccessibleObject;
     _monthCalendarAccessibleObject = monthCalendarAccessibleObject;
     _calendarIndex = calendarIndex;
     _rowIndex      = rowIndex;
     _columnIndex   = columnIndex;
     // RuntimeId don't change if the calendar date range is not changed,
     // otherwise the calendar accessibility tree will be rebuilt.
     // So save this value one time to avoid recreating new structures and making extra calculations.
     _initRuntimeId = new int[]
     {
         _calendarRowAccessibleObject.RuntimeId[0],
         _calendarRowAccessibleObject.RuntimeId[1],
         _calendarRowAccessibleObject.RuntimeId[2],
         _calendarRowAccessibleObject.RuntimeId[3],
         _calendarRowAccessibleObject.RuntimeId[4],
         GetChildId()
     };
 }
Example #3
0
        public void CalendarBodyAccessibleObject_ctor_Default()
        {
            using MonthCalendar calendar = new MonthCalendar();
            MonthCalendarAccessibleObject calendarAccessibleObject = new MonthCalendarAccessibleObject(calendar);
            CalendarBodyAccessibleObject  bodyAccessibleObject     = new CalendarBodyAccessibleObject(calendarAccessibleObject, 0);

            Assert.Equal(calendarAccessibleObject, bodyAccessibleObject.Parent);
        }
Example #4
0
        private CalendarHeaderAccessibleObject CreateCalendarHeaderAccessibleObject(MonthCalendar control, int calendarIndex = 0)
        {
            MonthCalendarAccessibleObject  controlAccessibleObject  = (MonthCalendarAccessibleObject)control.AccessibilityObject;
            CalendarAccessibleObject       calendarAccessibleObject = new(controlAccessibleObject, calendarIndex, "Test name");
            CalendarHeaderAccessibleObject headerAccessibleObject   = new(calendarAccessibleObject, controlAccessibleObject, calendarIndex);

            return(headerAccessibleObject);
        }
Example #5
0
        public void CalendarChildAccessibleObject_ctor_ThrowsException_IfParentAccessibleObjectIsNull()
        {
            using MonthCalendar calendar = new MonthCalendar();
            MonthCalendarAccessibleObject calendarAccessibleObject = new MonthCalendarAccessibleObject(calendar);

            Assert.Throws <ArgumentNullException>(
                () => new SubObject(calendarAccessibleObject, 0, CalendarChildType.CalendarBody, null, 0));
        }
        public void CalendarButtonAccessibleObject_GetPropertyValue_LegacyIAccessibleDefaultActionPropertyId_ReturnsExpected()
        {
            using MonthCalendar control = new();
            MonthCalendarAccessibleObject  controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
            CalendarButtonAccessibleObject buttonAccessibleObject  = new SubCalendarButtonAccessibleObject(controlAccessibleObject);

            Assert.Equal(SR.AccessibleActionClick, buttonAccessibleObject.GetPropertyValue(UiaCore.UIA.LegacyIAccessibleDefaultActionPropertyId));
            Assert.False(control.IsHandleCreated);
        }
        public void MonthCalendarAccessibleObject_GetCalendarRow_DoesntThrowException_If_ParentAccessibleObject_IsNull()
        {
            using MonthCalendar monthCalendar = new MonthCalendar();
            MonthCalendarAccessibleObject accessibleObject = (MonthCalendarAccessibleObject)monthCalendar.AccessibilityObject;
            Type       type   = typeof(MonthCalendarAccessibleObject);
            MethodInfo method = type.GetMethod("GetCalendarCell", BindingFlags.NonPublic | BindingFlags.Instance);

            Assert.Null(method.Invoke(accessibleObject, new object[] { 0, /*parentAccessibleObject*/ null, 0 }));
        }
        public void CalendarButtonAccessibleObject_DefaultAction_ReturnsExpected()
        {
            using MonthCalendar control = new();
            MonthCalendarAccessibleObject  controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
            CalendarButtonAccessibleObject buttonAccessibleObject  = new SubCalendarButtonAccessibleObject(controlAccessibleObject);

            Assert.Equal(SR.AccessibleActionClick, buttonAccessibleObject.DefaultAction);
            Assert.False(control.IsHandleCreated);
        }
        private CalendarRowAccessibleObject CreateCalendarRowAccessibleObject(MonthCalendar control, int calendarIndex = 0, int rowIndex = 0)
        {
            MonthCalendarAccessibleObject controlAccessibleObject  = (MonthCalendarAccessibleObject)control.AccessibilityObject;
            CalendarAccessibleObject      calendarAccessibleObject = new(controlAccessibleObject, calendarIndex, "Test name");
            CalendarBodyAccessibleObject  bodyAccessibleObject     = new(calendarAccessibleObject, controlAccessibleObject, calendarIndex);
            CalendarRowAccessibleObject   rowAccessibleObject      = new(bodyAccessibleObject, controlAccessibleObject, calendarIndex, rowIndex);

            return(rowAccessibleObject);
        }
        public void MonthCalendarChildAccessibleObject_FragmentNavigate_DoesntHaveChildrenAndSiblings(int direction)
        {
            using MonthCalendar control = new MonthCalendar();

            MonthCalendarAccessibleObject      controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
            MonthCalendarChildAccessibleObject accessibleObject        = new SubObject(controlAccessibleObject);

            Assert.Null(accessibleObject.FragmentNavigate((UiaCore.NavigateDirection)direction));
            Assert.False(control.IsHandleCreated);
        }
        public void MonthCalendarChildAccessibleObject_FragmentRoot_IsControlAccessibleObject()
        {
            using MonthCalendar control = new MonthCalendar();

            MonthCalendarAccessibleObject      controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
            MonthCalendarChildAccessibleObject accessibleObject        = new SubObject(controlAccessibleObject);

            Assert.Equal(controlAccessibleObject, accessibleObject.FragmentRoot);
            Assert.False(control.IsHandleCreated);
        }
        public void MonthCalendarChildAccessibleObject_LegacyIAccessiblePattern_IsSupported()
        {
            using MonthCalendar control = new MonthCalendar();

            MonthCalendarAccessibleObject      controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
            MonthCalendarChildAccessibleObject accessibleObject        = new SubObject(controlAccessibleObject);

            Assert.True(accessibleObject.IsPatternSupported(UiaCore.UIA.LegacyIAccessiblePatternId));
            Assert.False(control.IsHandleCreated);
        }
        public void MonthCalendarChildAccessibleObject_FragmentNavigate_Parent_IsNull()
        {
            using MonthCalendar control = new MonthCalendar();

            MonthCalendarAccessibleObject      controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
            MonthCalendarChildAccessibleObject accessibleObject        = new SubObject(controlAccessibleObject);

            Assert.Null(accessibleObject.FragmentNavigate(UiaCore.NavigateDirection.Parent));
            Assert.False(control.IsHandleCreated);
        }
        public void CalendarButtonAccessibleObject_ctor_default()
        {
            using MonthCalendar control = new();
            MonthCalendarAccessibleObject  controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
            CalendarButtonAccessibleObject buttonAccessibleObject  = new SubCalendarButtonAccessibleObject(controlAccessibleObject);

            Assert.Equal(controlAccessibleObject, buttonAccessibleObject.Parent);
            Assert.Equal(controlAccessibleObject, buttonAccessibleObject.TestAccessor().Dynamic._monthCalendarAccessibleObject);
            Assert.False(control.IsHandleCreated);
        }
Example #15
0
        public void CalendarBodyAccessibleObject_Parent_IsCalendarAccessibleObject()
        {
            using MonthCalendar control = new MonthCalendar();
            MonthCalendarAccessibleObject controlAccessibleObject  = (MonthCalendarAccessibleObject)control.AccessibilityObject;
            CalendarAccessibleObject      calendarAccessibleObject = new(controlAccessibleObject, 0, "Test name");
            CalendarBodyAccessibleObject  accessibleObject         = new(calendarAccessibleObject, controlAccessibleObject, 0);

            Assert.Equal(calendarAccessibleObject, accessibleObject.Parent);
            Assert.False(control.IsHandleCreated);
        }
Example #16
0
 public CalendarAccessibleObject(MonthCalendarAccessibleObject calendarAccessibleObject, int calendarIndex, string initName)
     : base(calendarAccessibleObject)
 {
     _monthCalendarAccessibleObject = calendarAccessibleObject;
     _calendarIndex = calendarIndex;
     // Name doesn't change if the calendar date range is not changed,
     // otherwise the calendar accessibility tree will be rebuilt.
     // So save this value one time to avoid sending messages to Windows every time.
     _initName = initName;
 }
        public void CalendarButtonAccessibleObject_Parent_IsCalendarAccessibleObject()
        {
            using MonthCalendar control = new();
            MonthCalendarAccessibleObject  controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
            CalendarButtonAccessibleObject buttonAccessibleObject  = new SubCalendarButtonAccessibleObject(controlAccessibleObject);

            AccessibleObject actual = buttonAccessibleObject.Parent;

            Assert.Equal(controlAccessibleObject, actual);
            Assert.False(control.IsHandleCreated);
        }
        public ScenarioResult MonthCalendarAccessibleObject_GetColumnHeaderItems_ReturnsCorrectCollection(TParams p)
        {
            using var wrapper = new MonthCalendarWrapper(this);
            Application.DoEvents();
            MonthCalendarAccessibleObject accessibleObject = (MonthCalendarAccessibleObject)wrapper.Calendar.AccessibilityObject;

            Application.DoEvents();
            IRawElementProviderSimple[] items = accessibleObject.GetColumnHeaderItems();

            return(new ScenarioResult(items != null));
        }
        public void CalendarButtonAccessibleObject_ControlType_IsButton()
        {
            using MonthCalendar control = new();
            MonthCalendarAccessibleObject  controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
            CalendarButtonAccessibleObject buttonAccessibleObject  = new SubCalendarButtonAccessibleObject(controlAccessibleObject);

            UiaCore.UIA actual = (UiaCore.UIA)buttonAccessibleObject.GetPropertyValue(UiaCore.UIA.ControlTypePropertyId);

            Assert.Equal(UiaCore.UIA.ButtonControlTypeId, actual);
            Assert.False(control.IsHandleCreated);
        }
        public void CalendarButtonAccessibleObject_Supports_InvokePattern()
        {
            using MonthCalendar control = new();
            MonthCalendarAccessibleObject  controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
            CalendarButtonAccessibleObject buttonAccessibleObject  = new SubCalendarButtonAccessibleObject(controlAccessibleObject);

            bool actual = buttonAccessibleObject.IsPatternSupported(UiaCore.UIA.InvokePatternId);

            Assert.True(actual);
            Assert.False(control.IsHandleCreated);
        }
        public void CalendarButtonAccessibleObject_Role_IsPushButton()
        {
            using MonthCalendar control = new();
            MonthCalendarAccessibleObject  controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
            CalendarButtonAccessibleObject buttonAccessibleObject  = new SubCalendarButtonAccessibleObject(controlAccessibleObject);

            AccessibleRole actual = buttonAccessibleObject.Role;

            Assert.Equal(AccessibleRole.PushButton, actual);
            Assert.False(control.IsHandleCreated);
        }
        public void MonthCalendarChildAccessibleObject_GetPropertyValue_ReturnsExpected(int property, object expected)
        {
            using MonthCalendar control = new MonthCalendar();

            MonthCalendarAccessibleObject      controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
            MonthCalendarChildAccessibleObject accessibleObject        = new SubObject(controlAccessibleObject);
            object actual = accessibleObject.GetPropertyValue((UiaCore.UIA)property);

            Assert.Equal(expected, actual);
            Assert.False(control.IsHandleCreated);
        }
Example #23
0
        public void CalendarHeaderAccessibleObject_Parent_ReturnsExpected()
        {
            using MonthCalendar control = new();
            MonthCalendarAccessibleObject  controlAccessibleObject  = (MonthCalendarAccessibleObject)control.AccessibilityObject;
            CalendarAccessibleObject       calendarAccessibleObject = new(controlAccessibleObject, 0, "Test name");
            CalendarHeaderAccessibleObject headerAccessibleObject   = new(calendarAccessibleObject, controlAccessibleObject, 0);

            AccessibleObject actual = headerAccessibleObject.Parent;

            Assert.Equal(calendarAccessibleObject, actual);
            Assert.False(control.IsHandleCreated);
        }
 public CalendarWeekNumberCellAccessibleObject(CalendarRowAccessibleObject calendarRowAccessibleObject,
                                               CalendarBodyAccessibleObject calendarBodyAccessibleObject,
                                               MonthCalendarAccessibleObject monthCalendarAccessibleObject,
                                               int calendarIndex, int rowIndex, int columnIndex, string weekNumber)
     : base(calendarRowAccessibleObject, calendarBodyAccessibleObject,
            monthCalendarAccessibleObject, calendarIndex, rowIndex, columnIndex)
 {
     _calendarRowAccessibleObject = calendarRowAccessibleObject;
     // Name don't change if the calendar date range is not changed,
     // otherwise the calendar accessibility tree will be rebuilt.
     // So save this value one time to avoid sending messages to Windows every time.
     _weekNumber = weekNumber;
 }
        public void MonthCalendarChildAccessibleObject_RuntimeId_HasThreeExpectedItems()
        {
            using MonthCalendar control = new MonthCalendar();

            control.CreateControl();
            MonthCalendarAccessibleObject      controlAccessibleObject = (MonthCalendarAccessibleObject)control.AccessibilityObject;
            MonthCalendarChildAccessibleObject accessibleObject        = new SubObject(controlAccessibleObject);

            Assert.Equal(3, accessibleObject.RuntimeId.Length);
            Assert.Equal(AccessibleObject.RuntimeIDFirstItem, accessibleObject.RuntimeId[0]);
            Assert.Equal(PARAM.ToInt(control.Handle), accessibleObject.RuntimeId[1]);
            Assert.Equal(accessibleObject.GetChildId(), accessibleObject.RuntimeId[2]);
            Assert.True(control.IsHandleCreated);
        }
        public ScenarioResult MonthCalendarAccessibleObject_GetColumnHeaderItems_ReturnsNull_IfCalendarIndexIsIncorrect(TParams p)
        {
            using var wrapper = new MonthCalendarWrapper(this);
            Application.DoEvents();
            MonthCalendarAccessibleObject accessibleObject = (MonthCalendarAccessibleObject)wrapper.Calendar.AccessibilityObject;
            Type type = typeof(MonthCalendarAccessibleObject);

            type.GetField("_calendarIndex", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(accessibleObject, -1);

            Application.DoEvents();
            IRawElementProviderSimple[] items = accessibleObject.GetColumnHeaderItems();

            return(new ScenarioResult(items is null));
        }
        public ScenarioResult MonthCalendarAccessibleObject_GetCalendarChildAccessibleObject_ReturnsNull_IfCalendarIndexIsIncorrect(TParams p)
        {
            using var wrapper = new MonthCalendarWrapper(this);
            Application.DoEvents();
            MonthCalendarAccessibleObject accessibleObject = (MonthCalendarAccessibleObject)wrapper.Calendar.AccessibilityObject;
            Type type = typeof(MonthCalendarAccessibleObject);

            type.GetField("_calendarIndex", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(accessibleObject, -1);
            MethodInfo method = type.GetMethod("GetCalendarChildAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);

            Application.DoEvents();
            object child = method.Invoke(accessibleObject, new object[] { new DateTime(2020, 4, 10), new DateTime(2020, 4, 10) });

            return(new ScenarioResult(child is null));
        }
        public ScenarioResult MonthCalendarAccessibleObject_GetCalendarChildAccessibleObject_ReturnsCorrecObject(TParams p)
        {
            using var wrapper = new MonthCalendarWrapper(this);
            DateTime selectedDate = new DateTime(2020, 4, 10);

            wrapper.Calendar.SetDate(selectedDate);
            Application.DoEvents();
            MonthCalendarAccessibleObject accessibleObject = (MonthCalendarAccessibleObject)wrapper.Calendar.AccessibilityObject;
            Type       type   = typeof(MonthCalendarAccessibleObject);
            MethodInfo method = type.GetMethod("GetCalendarChildAccessibleObject", BindingFlags.NonPublic | BindingFlags.Instance);

            Application.DoEvents();
            object child = method.Invoke(accessibleObject, new object[] { selectedDate, selectedDate });

            return(new ScenarioResult(child != null));
        }
        public ScenarioResult CalendarBodyAccessibleObject_GetFromPoint_ReturnsNull_IfMCHITTESTINFOIsIncorrect(TParams p)
        {
            using var wrapper = new MonthCalendarWrapper(this);
            Application.DoEvents();
            MonthCalendarAccessibleObject accessibleObject     = (MonthCalendarAccessibleObject)wrapper.Calendar.AccessibilityObject;
            CalendarBodyAccessibleObject  bodyAccessibleObject = new CalendarBodyAccessibleObject(accessibleObject, 0);
            MCHITTESTINFO info = new MCHITTESTINFO
            {
                uHit = MCHT.CALENDARDAY,
                iRow = -10
            };

            Application.DoEvents();
            CalendarChildAccessibleObject cell = bodyAccessibleObject.GetFromPoint(info);

            return(new ScenarioResult(cell is null));
        }
Example #30
0
        public ScenarioResult MonthCalendar_GetFromPoint_ReturnsCorrectValue(TParams p)
        {
            using var wrapper = new MonthCalendarWrapper(this);
            Application.DoEvents();
            MonthCalendarAccessibleObject accessibleObject         = (MonthCalendarAccessibleObject)wrapper.Calendar.AccessibilityObject;
            CalendarAccessibleObject      calendarAccessibleObject = new CalendarAccessibleObject(accessibleObject, 0, "Test name");
            MCHITTESTINFO info = new MCHITTESTINFO
            {
                uHit = MCHT.CALENDARDAY,
                iRow = 0
            };

            Application.DoEvents();
            MonthCalendarChildAccessibleObject cell = calendarAccessibleObject.GetChildFromPoint(info);

            return(new ScenarioResult(cell != null));
        }