public static void Main(string[] args)
{
string peerServer = "ws://localhost:8080/ws";
if (args.Length == 1)
{
peerServer = args[0];
}
TestPeer app = new TestPeer();
if (!HumbleNet.Init())
{
Console.WriteLine("Failed to startup");
return;
}
HumbleNet.P2P.Initialize(peerServer, "client_token", "client_secret", null);
app.Start();
while (app.Run())
{
}
app.Stop();
HumbleNet.Shutdown();
}
public void CreatePlugin()
{
var plugin = new TestApplication();
var Clients = new List <PeerBase>();
var tcp = plugin.GetTransportByName("TCPIPV4");
plugin.RegisterReceiveCommand(tcp, new LogInRequest());
var connection = ServerConnectionFactory.Create(plugin.GetTransportByName("TCPIPV4"), Guid.NewGuid().ToString());
var byteconn = connection as ServerConnection <byte[]>;
byteconn.DeSerializer = new ProtoBufGenericSerializer <LogInRequest>();
plugin.OnClientConnected += (sender, conn) =>
{
var peer = new TestPeer(conn);
Clients.Add(peer);
};
plugin.RaiseClientConnected(connection);
plugin.RaisePacketReceived(connection);
}
public void DataGridCell_ITableItemProvider()
{
List<Customer> boundList = CreateCustomerList(10);
DataGrid dataGrid = new DataGrid();
Assert.IsNotNull(dataGrid);
isLoaded = false;
dataGrid.Width = 350;
dataGrid.Height = 250;
dataGrid.HeadersVisibility = DataGridHeadersVisibility.All;
dataGrid.Loaded += new RoutedEventHandler(dataGrid_Loaded);
dataGrid.AutoGenerateColumns = true;
dataGrid.ItemsSource = boundList;
dataGrid.ColumnWidth = new DataGridLength(100.0);
TestPeer testPeer = new TestPeer(dataGrid);
TestPanel.Children.Add(dataGrid);
EnqueueConditional(delegate { return isLoaded; });
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
// Get automation peers and the selection item provider for (0,0)
DataGridRow row = dataGrid.DisplayData.GetDisplayedRow(1);
AutomationPeer rowPeer = DataGridAutomationPeer.CreatePeerForElement(row);
DataGridCell cell = row.Cells[2];
AutomationPeer cellPeer = DataGridAutomationPeer.CreatePeerForElement(cell);
Assert.IsNotNull(cellPeer);
ITableItemProvider tableItem = cellPeer.GetPattern(PatternInterface.TableItem) as ITableItemProvider;
Assert.IsNotNull(tableItem);
// Test GetColumnHeaders
IRawElementProviderSimple[] headers = tableItem.GetColumnHeaderItems();
Assert.AreEqual(1, headers.Length);
AutomationPeer headerPeer = DataGridAutomationPeer.CreatePeerForElement(dataGrid.Columns[2].HeaderCell);
Assert.AreEqual(headerPeer, testPeer.GetPeerFromProvider(headers[0]));
// Test GetRowHeaders
headers = tableItem.GetRowHeaderItems();
Assert.AreEqual(1, headers.Length);
headerPeer = DataGridAutomationPeer.CreatePeerForElement(row.HeaderCell);
Assert.AreEqual(headerPeer, testPeer.GetPeerFromProvider(headers[0]));
});
EnqueueTestComplete();
}
public void DataGridCell_ISelectionItemProvider()
{
List<Customer> boundList = CreateCustomerList(10);
DataGrid dataGrid = new DataGrid();
Assert.IsNotNull(dataGrid);
isLoaded = false;
dataGrid.Width = 350;
dataGrid.Height = 250;
dataGrid.Loaded += new RoutedEventHandler(dataGrid_Loaded);
dataGrid.AutoGenerateColumns = true;
dataGrid.ItemsSource = boundList;
dataGrid.ColumnWidth = new DataGridLength(100.0);
TestPeer testPeer = new TestPeer(dataGrid);
TestPanel.Children.Add(dataGrid);
EnqueueConditional(delegate { return isLoaded; });
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
// Get automation peers and the selection item provider for (0,0)
DataGridRow row = dataGrid.DisplayData.GetDisplayedRow(0);
AutomationPeer rowPeer = DataGridAutomationPeer.CreatePeerForElement(row);
DataGridCell cell = row.Cells[0];
AutomationPeer peer = DataGridAutomationPeer.CreatePeerForElement(cell);
Assert.IsNotNull(peer);
ISelectionItemProvider selectionItem = peer.GetPattern(PatternInterface.SelectionItem) as ISelectionItemProvider;
Assert.IsNotNull(selectionItem);
// Test the properties
Assert.IsTrue(selectionItem.IsSelected);
Assert.AreEqual(rowPeer, testPeer.GetPeerFromProvider(selectionItem.SelectionContainer));
//
// Get a new selection item provider for a new cell (3,2)
row = dataGrid.DisplayData.GetDisplayedRow(3);
rowPeer = DataGridAutomationPeer.CreatePeerForElement(row);
cell = row.Cells[2];
peer = DataGridAutomationPeer.CreatePeerForElement(cell);
Assert.IsNotNull(peer);
selectionItem = peer.GetPattern(PatternInterface.SelectionItem) as ISelectionItemProvider;
Assert.IsNotNull(selectionItem);
// Test the new cell
Assert.IsFalse(selectionItem.IsSelected);
Assert.AreEqual(rowPeer, testPeer.GetPeerFromProvider(selectionItem.SelectionContainer));
//
selectionItem.Select();
});
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
Assert.AreEqual(2, dataGrid.CurrentColumnIndex);
Assert.AreEqual(3, dataGrid.CurrentSlot);
Assert.AreEqual(3, dataGrid.SelectedIndex);
});
EnqueueTestComplete();
}
public void DataGridCell_IGridItemProvider()
{
List<Customer> boundList = CreateCustomerList(5);
DataGrid dataGrid = new DataGrid();
Assert.IsNotNull(dataGrid);
isLoaded = false;
dataGrid.Width = 200;
dataGrid.Height = 250;
dataGrid.Loaded += new RoutedEventHandler(dataGrid_Loaded);
dataGrid.AutoGenerateColumns = true;
dataGrid.ItemsSource = boundList;
DataGridAutomationPeer gridPeer = ((DataGridAutomationPeer)DataGridAutomationPeer.CreatePeerForElement(dataGrid));
Assert.IsNotNull(gridPeer);
TestPeer testPeer = new TestPeer(dataGrid);
TestPanel.Children.Add(dataGrid);
EnqueueConditional(delegate { return isLoaded; });
this.EnqueueYieldThread();
AutomationPeer peer;
IGridItemProvider gridItem;
EnqueueCallback(delegate
{
foreach (DataGridRow row in dataGrid.DisplayData.GetScrollingRows())
{
foreach (DataGridCell cell in row.Cells)
{
peer = DataGridAutomationPeer.CreatePeerForElement(cell);
Assert.IsNotNull(peer);
gridItem = (IGridItemProvider)peer.GetPattern(PatternInterface.GridItem);
Assert.IsNotNull(gridItem);
Assert.AreEqual(cell.ColumnIndex, gridItem.Column);
Assert.AreEqual(cell.RowIndex, gridItem.Row);
Assert.AreEqual(1, gridItem.ColumnSpan);
Assert.AreEqual(1, gridItem.RowSpan);
Assert.AreEqual(gridPeer, testPeer.GetPeerFromProvider(gridItem.ContainingGrid));
}
}
Assert.IsNotNull(dataGrid.DataConnection.CollectionView);
dataGrid.DataConnection.CollectionView.GroupDescriptions.Add(new PropertyGroupDescription("LastName"));
dataGrid.DataConnection.CollectionView.GroupDescriptions.Add(new PropertyGroupDescription("FirstName"));
});
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
foreach (DataGridRow row in dataGrid.DisplayData.GetScrollingRows())
{
foreach (DataGridColumn column in dataGrid.Columns)
{
DataGridCell cell = row.Cells[column.Index];
peer = DataGridAutomationPeer.CreatePeerForElement(cell);
Assert.IsNotNull(peer);
gridItem = (IGridItemProvider)peer.GetPattern(PatternInterface.GridItem);
Assert.IsNotNull(gridItem);
Assert.AreEqual(cell.ColumnIndex - 1, gridItem.Column, "GridItemProvider.Column did not account for filler column");
Assert.AreEqual(cell.RowIndex, gridItem.Row, "GridItemProvider.Row is incorrect");
Assert.AreEqual(1, gridItem.ColumnSpan, "GridItemProvider.ColumnSpan is incorrect");
Assert.AreEqual(1, gridItem.RowSpan, "GridItemProvider.RowSpan is incorrect");
Assert.AreEqual(gridPeer, testPeer.GetPeerFromProvider(gridItem.ContainingGrid), "GridItemProvider.ContainingGrid is incorrect");
}
}
});
EnqueueTestComplete();
}
public void DataGrid_ISelectionProvider()
{
List<Customer> boundList = CreateCustomerList(25);
DataGrid dataGrid = new DataGrid();
Assert.IsNotNull(dataGrid);
isLoaded = false;
dataGrid.Width = 350;
dataGrid.Height = 250;
dataGrid.Loaded += new RoutedEventHandler(dataGrid_Loaded);
dataGrid.AutoGenerateColumns = true;
dataGrid.ItemsSource = boundList;
dataGrid.SelectedIndex = 0;
DataGridAutomationPeer peer = ((DataGridAutomationPeer)DataGridAutomationPeer.CreatePeerForElement(dataGrid));
Assert.IsNotNull(peer);
ISelectionProvider selectionProvider = ((ISelectionProvider)peer.GetPattern(PatternInterface.Selection));
Assert.IsNotNull(selectionProvider);
TestPeer testPeer = new TestPeer(dataGrid);
Assert.IsNotNull(testPeer);
TestPanel.Children.Add(dataGrid);
EnqueueConditional(delegate { return isLoaded; });
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
IRawElementProviderSimple[] selection = selectionProvider.GetSelection();
Assert.IsNotNull(selection, "GetSelection returned null for valid row");
AutomationPeer selectionPeer = testPeer.GetPeerFromProvider(selection[0]);
Assert.AreEqual(typeof(DataGridRow).Name, selectionPeer.GetClassName(), "GetSelection did not return DataGridRow");
Assert.AreEqual(dataGrid.SelectionMode == DataGridSelectionMode.Extended, selectionProvider.CanSelectMultiple, "Incorrect CanSelectMultiple value");
Assert.AreEqual(false, selectionProvider.IsSelectionRequired, "Incorrect IsSelectionRequired value");
});
EnqueueTestComplete();
}
public void DataGridItem_ISelectionProvider()
{
List<Customer> boundList = CreateCustomerList(5);
DataGrid dataGrid = new DataGrid();
Assert.IsNotNull(dataGrid);
isLoaded = false;
dataGrid.Width = 350;
dataGrid.Height = 250;
dataGrid.Loaded += new RoutedEventHandler(dataGrid_Loaded);
dataGrid.AutoGenerateColumns = true;
dataGrid.ItemsSource = boundList;
dataGrid.ColumnWidth = new DataGridLength(100.0);
TestPanel.Children.Add(dataGrid);
EnqueueConditional(delegate { return isLoaded; });
this.EnqueueYieldThread();
AutomationPeer peer;
ISelectionProvider selector;
TestPeer testPeer = new TestPeer(dataGrid);
EnqueueCallback(delegate
{
peer = new DataGridItemAutomationPeer(boundList[0], dataGrid);
Assert.IsNotNull(peer);
selector = peer.GetPattern(PatternInterface.Selection) as ISelectionProvider;
Assert.IsNotNull(selector);
Assert.AreEqual(1, selector.GetSelection().Length);
peer = testPeer.GetPeerFromProvider(selector.GetSelection()[0]);
Assert.AreEqual(typeof(DataGridCell).Name, peer.GetClassName(), "GetSelection did not return DataGridCell");
});
this.EnqueueYieldThread();
EnqueueTestComplete();
}
public void DataGridGroupItem_ISelectionProvider()
{
PagedCollectionView customers = CreateGroupedCustomerCollectionView();
DataGrid dataGrid = new DataGrid();
Assert.IsNotNull(dataGrid);
isLoaded = false;
dataGrid.Width = 350;
dataGrid.Height = 250;
dataGrid.Loaded += new RoutedEventHandler(dataGrid_Loaded);
dataGrid.AutoGenerateColumns = true;
dataGrid.ItemsSource = customers;
TestPanel.Children.Add(dataGrid);
EnqueueConditional(delegate { return isLoaded; });
this.EnqueueYieldThread();
AutomationPeer peer;
ISelectionProvider selector = null;
TestPeer testPeer = new TestPeer(dataGrid);
EnqueueCallback(delegate
{
CollectionViewGroup group = customers.Groups[1] as CollectionViewGroup;
Assert.IsNotNull(group, "PagedCollectionView did not return CollectionViewGroup");
peer = new DataGridGroupItemAutomationPeer(group, dataGrid);
Assert.IsNotNull(peer);
selector = peer.GetPattern(PatternInterface.Selection) as ISelectionProvider;
Assert.IsNotNull(selector);
Assert.AreEqual(0, selector.GetSelection().Length, "There should not be any selected items within this group");
// Select an item within group 1
peer = new DataGridItemAutomationPeer(customers[3], dataGrid);
Assert.IsNotNull(peer);
ISelectionItemProvider selectionItem = peer.GetPattern(PatternInterface.SelectionItem) as ISelectionItemProvider;
Assert.IsNotNull(selectionItem);
selectionItem.AddToSelection();
});
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
Assert.IsNotNull(selector);
Assert.AreEqual(1, selector.GetSelection().Length, "There should be a single selected item within this group");
peer = testPeer.GetPeerFromProvider(selector.GetSelection()[0]);
Assert.AreEqual(typeof(DataGridRow).Name, peer.GetClassName(), "GetSelection did not return DataGridRow");
});
this.EnqueueYieldThread();
EnqueueTestComplete();
}
public void DataGridGroupItem_IGridProvider()
{
PagedCollectionView customers = CreateGroupedCustomerCollectionView();
DataGrid dataGrid = new DataGrid();
Assert.IsNotNull(dataGrid);
isLoaded = false;
dataGrid.Width = 350;
dataGrid.Height = 250;
dataGrid.Loaded += new RoutedEventHandler(dataGrid_Loaded);
dataGrid.AutoGenerateColumns = true;
dataGrid.ItemsSource = customers;
TestPeer testPeer = new TestPeer(dataGrid);
Assert.IsNotNull(testPeer);
TestPanel.Children.Add(dataGrid);
EnqueueConditional(delegate { return isLoaded; });
this.EnqueueYieldThread();
IGridProvider gridProvider = null;
IRawElementProviderSimple item = null;
EnqueueCallback(delegate
{
CollectionViewGroup group = customers.Groups[1] as CollectionViewGroup;
Assert.IsNotNull(group, "PagedCollectionView did not return CollectionViewGroup");
AutomationPeer peer = new DataGridGroupItemAutomationPeer(group, dataGrid);
Assert.IsNotNull(peer);
gridProvider = peer.GetPattern(PatternInterface.Grid) as IGridProvider;
Assert.IsNotNull(gridProvider);
Assert.AreEqual(7, gridProvider.RowCount, "Incorrect RowCount value");
Assert.AreEqual(dataGrid.Columns.Count, gridProvider.ColumnCount, "Incorrect ColumnCount value");
item = gridProvider.GetItem(5, 2);
Assert.IsNotNull(item, "GetItem returned null for valid cell");
AutomationPeer itemPeer = testPeer.GetPeerFromProvider(item);
Assert.AreEqual(typeof(DataGridCell).Name, itemPeer.GetClassName(), "GetItem did not return DataGridCell");
item = gridProvider.GetItem(100, 100);
Assert.IsNull(item, "GetItem returned object for invalid cell");
});
this.EnqueueYieldThread();
this.EnqueueCallback(delegate
{
// Collapse the group and check that GetItem still works
dataGrid.CollapseRowGroup(customers.Groups[1] as CollectionViewGroup, true);
});
this.EnqueueYieldThread();
this.EnqueueCallback(delegate
{
Assert.IsNotNull(gridProvider);
item = gridProvider.GetItem(5, 2);
Assert.IsNotNull(item, "GetItem returned null for valid cell");
AutomationPeer itemPeer = testPeer.GetPeerFromProvider(item);
Assert.AreEqual(typeof(DataGridCell).Name, itemPeer.GetClassName(), "GetItem did not return DataGridCell");
});
EnqueueTestComplete();
}
public void DataGrid_IGridProvider()
{
List<Customer> boundList = CreateCustomerList(25);
DataGrid dataGrid = new DataGrid();
Assert.IsNotNull(dataGrid);
isLoaded = false;
dataGrid.Width = 350;
dataGrid.Height = 250;
dataGrid.Loaded += new RoutedEventHandler(dataGrid_Loaded);
dataGrid.AutoGenerateColumns = true;
dataGrid.ItemsSource = boundList;
DataGridAutomationPeer peer = ((DataGridAutomationPeer)DataGridAutomationPeer.CreatePeerForElement(dataGrid));
Assert.IsNotNull(peer);
IGridProvider gridProvider = ((IGridProvider)peer.GetPattern(PatternInterface.Grid));
Assert.IsNotNull(gridProvider);
TestPeer testPeer = new TestPeer(dataGrid);
Assert.IsNotNull(testPeer);
TestPanel.Children.Add(dataGrid);
EnqueueConditional(delegate { return isLoaded; });
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
Assert.AreEqual(dataGrid.SlotCount, gridProvider.RowCount, "Incorrect RowCount value");
Assert.AreEqual(dataGrid.Columns.Count, gridProvider.ColumnCount, "Incorrect ColumnCount value");
IRawElementProviderSimple item = gridProvider.GetItem(21, 2);
Assert.IsNotNull(item, "GetItem returned null for valid cell");
AutomationPeer itemPeer = testPeer.GetPeerFromProvider(item);
Assert.AreEqual(typeof(DataGridCell).Name, itemPeer.GetClassName(), "GetItem did not return DataGridCell");
item = gridProvider.GetItem(100, 100);
Assert.IsNull(item, "GetItem returned object for invalid cell");
});
EnqueueTestComplete();
}
public void DataGridGroupItem_IExpandCollapseProvider()
{
PagedCollectionView customers = CreateGroupedCustomerCollectionView();
DataGrid dataGrid = new DataGrid();
Assert.IsNotNull(dataGrid);
isLoaded = false;
dataGrid.Width = 350;
dataGrid.Height = 250;
dataGrid.Loaded += new RoutedEventHandler(dataGrid_Loaded);
dataGrid.AutoGenerateColumns = true;
dataGrid.ItemsSource = customers;
CollectionViewGroup group = null;
IExpandCollapseProvider expandCollapseProvider = null;
TestPeer testPeer = new TestPeer(dataGrid);
Assert.IsNotNull(testPeer);
TestPanel.Children.Add(dataGrid);
EnqueueConditional(delegate { return isLoaded; });
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
group = customers.Groups[1] as CollectionViewGroup;
Assert.IsNotNull(group, "PagedCollectionView did not return CollectionViewGroup");
AutomationPeer peer = new DataGridGroupItemAutomationPeer(group, dataGrid);
Assert.IsNotNull(peer);
expandCollapseProvider = peer.GetPattern(PatternInterface.ExpandCollapse) as IExpandCollapseProvider;
Assert.IsNotNull(expandCollapseProvider);
Assert.AreEqual(Visibility.Visible, dataGrid.RowGroupInfoFromCollectionViewGroup(group).Visibility, "Group should be expanded");
Assert.AreEqual(ExpandCollapseState.Expanded, expandCollapseProvider.ExpandCollapseState, "Group should be expanded");
expandCollapseProvider.Collapse();
});
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
Assert.IsNotNull(expandCollapseProvider);
Assert.AreEqual(Visibility.Collapsed, dataGrid.RowGroupInfoFromCollectionViewGroup(group).Visibility, "Group should be collapsed");
Assert.AreEqual(ExpandCollapseState.Collapsed, expandCollapseProvider.ExpandCollapseState, "Group should be collapsed");
expandCollapseProvider.Expand();
});
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
Assert.IsNotNull(expandCollapseProvider);
Assert.AreEqual(Visibility.Visible, dataGrid.RowGroupInfoFromCollectionViewGroup(group).Visibility, "Group should be expanded");
Assert.AreEqual(ExpandCollapseState.Expanded, expandCollapseProvider.ExpandCollapseState, "Group should be expanded");
});
EnqueueTestComplete();
}
public void DataGridCell_IGridItemProvider()
{
List<Customer> boundList = CreateCustomerList(5);
DataGrid dataGrid = new DataGrid();
Assert.IsNotNull(dataGrid);
isLoaded = false;
dataGrid.Width = 200;
dataGrid.Height = 250;
dataGrid.Loaded += new RoutedEventHandler(dataGrid_Loaded);
dataGrid.AutoGenerateColumns = true;
dataGrid.ItemsSource = boundList;
DataGridAutomationPeer gridPeer = ((DataGridAutomationPeer)DataGridAutomationPeer.CreatePeerForElement(dataGrid));
Assert.IsNotNull(gridPeer);
TestPeer testPeer = new TestPeer(dataGrid);
TestPanel.Children.Add(dataGrid);
EnqueueConditional(delegate { return isLoaded; });
this.EnqueueYieldThread();
EnqueueCallback(delegate
{
AutomationPeer peer;
IGridItemProvider gridItem;
foreach (DataGridRow row in dataGrid.DisplayData.GetScrollingRows())
{
foreach (DataGridCell cell in row.Cells)
{
peer = DataGridAutomationPeer.CreatePeerForElement(cell);
Assert.IsNotNull(peer);
gridItem = (IGridItemProvider)peer.GetPattern(PatternInterface.GridItem);
Assert.IsNotNull(gridItem);
Assert.AreEqual(cell.ColumnIndex, gridItem.Column);
Assert.AreEqual(cell.RowIndex, gridItem.Row);
Assert.AreEqual(1, gridItem.ColumnSpan);
Assert.AreEqual(1, gridItem.RowSpan);
Assert.AreEqual(gridPeer, testPeer.GetPeerFromProvider(gridItem.ContainingGrid));
}
}
});
EnqueueTestComplete();
}
public void CalendarButton_AutomationPeer()
{
Calendar calendar = new Calendar();
Assert.IsNotNull(calendar);
_isLoaded = false;
DateTime date = new DateTime(2000, 2, 2);
calendar.DisplayDate = date;
calendar.SelectedDate = date;
CalendarAutomationPeer calendarAutomationPeer = (CalendarAutomationPeer)CalendarAutomationPeer.CreatePeerForElement(calendar);
Assert.IsNotNull(calendarAutomationPeer);
TestPeer testPeer = new TestPeer(calendar);
calendar.Loaded += new RoutedEventHandler(calendar_Loaded);
TestPanel.Children.Add(calendar);
EnqueueConditional(IsLoaded);
EnqueueCallback(delegate
{
calendar._hasFocus = true;
calendar.DisplayMode = CalendarMode.Year;
CalendarButton calendarButton = (CalendarButton)calendar.MonthControl.YearView.Children[1];
Assert.IsNotNull(calendarButton);
AutomationPeer peer = CalendarAutomationPeer.CreatePeerForElement(calendarButton);
Assert.IsNotNull(peer);
date = new DateTime(2000, 2, 1);
Assert.AreEqual(peer.GetAutomationControlType(), AutomationControlType.Button, "Incorrect Control type for CalendarButton");
Assert.AreEqual(peer.GetClassName(), calendarButton.GetType().Name, "Incorrect ClassName value for CalendarButton");
Assert.AreEqual(peer.GetName(), calendarButton.Content.ToString(), "Incorrect Name value for CalendarButton");
Assert.IsTrue(peer.IsContentElement(), "Incorrect IsContentElement value");
Assert.IsTrue(peer.IsControlElement(), "Incorrect IsControlElement value");
Assert.IsFalse(peer.IsKeyboardFocusable(), "Incorrect IsKeyBoardFocusable value");
#region CalendarButtonAutomationPeer ISelectionItemProvider tests:
ISelectionItemProvider selectionItem = (ISelectionItemProvider)peer.GetPattern(PatternInterface.SelectionItem);
Assert.IsNotNull(selectionItem);
Assert.IsTrue(calendarButton.IsFocusedOverride);
Assert.IsTrue(selectionItem.IsSelected);
Assert.AreEqual(calendarAutomationPeer, testPeer.GetPeerFromProvider(selectionItem.SelectionContainer));
selectionItem.RemoveFromSelection();
Assert.IsTrue(selectionItem.IsSelected);
CalendarButton calendarButton2 = (CalendarButton)calendar.MonthControl.YearView.Children[0];
Assert.IsNotNull(calendarButton2);
AutomationPeer peer2 = CalendarAutomationPeer.CreatePeerForElement(calendarButton2);
Assert.IsNotNull(peer2);
ISelectionItemProvider selectionItem2 = (ISelectionItemProvider)peer2.GetPattern(PatternInterface.SelectionItem);
Assert.IsNotNull(selectionItem2);
selectionItem2.AddToSelection();
Assert.IsTrue(selectionItem.IsSelected);
Assert.IsFalse(calendarButton2.IsFocusedOverride);
Assert.IsFalse(selectionItem2.IsSelected);
selectionItem2.Select();
Assert.IsTrue(selectionItem2.IsSelected);
Assert.IsFalse(selectionItem.IsSelected);
Assert.IsFalse(calendarButton.IsFocusedOverride);
Assert.IsTrue(calendarButton2.IsFocusedOverride);
calendar.DisplayDateEnd = new DateTime(2000, 9, 1);
CalendarButton calendarButton3 = (CalendarButton)calendar.MonthControl.YearView.Children[10];
Assert.IsFalse(calendarButton3.IsEnabled);
AutomationPeer peer3 = CalendarAutomationPeer.CreatePeerForElement(calendarButton3);
Assert.IsNotNull(peer3);
ISelectionItemProvider selectionItem3 = (ISelectionItemProvider)peer3.GetPattern(PatternInterface.SelectionItem);
Assert.IsNotNull(selectionItem3);
Common.AssertExpectedExceptionWithoutMessageControl(new ElementNotEnabledException(), () => { selectionItem3.Select(); });
#endregion
#region CalendarButtonAutomationPeer IGridItemProvider tests:
foreach (UIElement child in calendar.MonthControl.YearView.Children)
{
int childRow = (int)child.GetValue(Grid.RowProperty);
IGridItemProvider gridItem;
if (childRow != 0)
{
peer = CalendarButtonAutomationPeer.CreatePeerForElement(child);
Assert.IsNotNull(peer);
gridItem = (IGridItemProvider)peer.GetPattern(PatternInterface.GridItem);
Assert.IsNotNull(gridItem);
Assert.AreEqual(child.GetValue(Grid.ColumnProperty), gridItem.Column);
Assert.AreEqual(child.GetValue(Grid.RowProperty), gridItem.Row);
Assert.AreEqual(1, gridItem.ColumnSpan);
Assert.AreEqual(1, gridItem.RowSpan);
Assert.AreEqual(calendarAutomationPeer, testPeer.GetPeerFromProvider(gridItem.ContainingGrid));
}
}
#endregion
#region CalendarButtonAutomation Peer IInvokeProvider tests:
Assert.AreEqual(calendar.DisplayMode, CalendarMode.Year);
calendarButton = (CalendarButton)calendar.MonthControl.YearView.Children[1];
peer = CalendarAutomationPeer.CreatePeerForElement(calendarButton);
IInvokeProvider invokeProvider = (IInvokeProvider)peer.GetPattern(PatternInterface.Invoke);
invokeProvider.Invoke();
Assert.AreEqual(calendar.DisplayMode, CalendarMode.Month);
#endregion
});
EnqueueTestComplete();
}
public void DayButton_AutomationPeer()
{
Calendar calendar = new Calendar();
Assert.IsNotNull(calendar);
_isLoaded = false;
DateTime date = new DateTime(2000, 2, 2);
calendar.DisplayDate = date;
calendar.SelectedDate = date;
CalendarAutomationPeer calendarAutomationPeer = (CalendarAutomationPeer)CalendarAutomationPeer.CreatePeerForElement(calendar);
Assert.IsNotNull(calendarAutomationPeer);
TestPeer testPeer = new TestPeer(calendar);
calendar.Loaded += new RoutedEventHandler(calendar_Loaded);
TestPanel.Children.Add(calendar);
EnqueueConditional(IsLoaded);
EnqueueCallback(delegate
{
CalendarDayButton dayButton = calendar.FindDayButtonFromDay(date);
Assert.IsNotNull(dayButton);
AutomationPeer peer = CalendarAutomationPeer.CreatePeerForElement(dayButton);
Assert.IsNotNull(peer);
Assert.AreEqual(peer.GetAutomationControlType(), AutomationControlType.Button, "Incorrect Control type for Daybutton");
Assert.AreEqual(peer.GetClassName(), dayButton.GetType().Name, "Incorrect ClassName value for DayButton");
Assert.AreEqual(peer.GetName(), dayButton.Content.ToString(), "Incorrect Name value for DayButtonPeer");
Assert.IsTrue(peer.IsContentElement(), "Incorrect IsContentElement value");
Assert.IsTrue(peer.IsControlElement(), "Incorrect IsControlElement value");
Assert.IsFalse(peer.IsKeyboardFocusable(), "Incorrect IsKeyBoardFocusable value");
#region DayButtonAutomationPeer ISelectionItemProvider tests:
ISelectionItemProvider selectionItem = (ISelectionItemProvider)peer.GetPattern(PatternInterface.SelectionItem);
Assert.IsNotNull(selectionItem);
Assert.IsTrue(selectionItem.IsSelected);
Assert.AreEqual(calendarAutomationPeer, testPeer.GetPeerFromProvider(selectionItem.SelectionContainer));
selectionItem.RemoveFromSelection();
Assert.IsFalse(selectionItem.IsSelected);
selectionItem.AddToSelection();
Assert.IsTrue(selectionItem.IsSelected);
//check selection in SingleDate mode
CalendarDayButton dayButton2 = calendar.FindDayButtonFromDay(date.AddDays(1));
Assert.IsNotNull(dayButton2);
AutomationPeer peer2 = CalendarAutomationPeer.CreatePeerForElement(dayButton2);
Assert.IsNotNull(peer2);
ISelectionItemProvider selectionItem2 = (ISelectionItemProvider)peer2.GetPattern(PatternInterface.SelectionItem);
Assert.IsNotNull(selectionItem2);
Assert.IsFalse(selectionItem2.IsSelected);
selectionItem2.AddToSelection();
Assert.IsTrue(selectionItem2.IsSelected);
Assert.IsFalse(selectionItem.IsSelected);
//check blackout day
selectionItem.RemoveFromSelection();
calendar.BlackoutDates.Add(new CalendarDateRange(date));
selectionItem.AddToSelection();
Assert.IsFalse(selectionItem.IsSelected);
//check selection in None mode
calendar.SelectionMode = CalendarSelectionMode.None;
Assert.IsFalse(selectionItem2.IsSelected);
selectionItem2.AddToSelection();
Assert.IsFalse(selectionItem2.IsSelected);
//check selection in MultiRange mode
calendar.BlackoutDates.Clear();
calendar.SelectionMode = CalendarSelectionMode.MultipleRange;
Assert.IsFalse(selectionItem.IsSelected);
Assert.IsFalse(selectionItem2.IsSelected);
selectionItem.AddToSelection();
selectionItem2.AddToSelection();
Assert.IsTrue(selectionItem.IsSelected);
Assert.IsTrue(selectionItem2.IsSelected);
selectionItem2.RemoveFromSelection();
Assert.IsTrue(selectionItem.IsSelected);
Assert.IsFalse(selectionItem2.IsSelected);
#endregion
#region DayButtonAutomationPeer IInvoke tests:
//check selection and trailing day functionality
CalendarDayButton dayButton4 = calendar.FindDayButtonFromDay(new DateTime(2000,1,31));
Assert.IsNotNull(dayButton4);
AutomationPeer peer4 = CalendarAutomationPeer.CreatePeerForElement(dayButton4);
Assert.IsNotNull(peer4);
IInvokeProvider invokeItem = (IInvokeProvider)peer4.GetPattern(PatternInterface.Invoke);
Assert.IsNotNull(invokeItem);
invokeItem.Invoke();
dayButton4 = calendar.FindDayButtonFromDay(new DateTime(2000, 1, 31));
Assert.IsTrue(dayButton4.IsSelected);
Assert.AreEqual(calendar.DisplayDate.Month, 1);
#endregion
#region DayButtonAutomationPeer ITableItemProvider tests:
ITableItemProvider tableItem = (ITableItemProvider)peer.GetPattern(PatternInterface.TableItem);
Assert.IsNotNull(tableItem);
IRawElementProviderSimple[] headers = tableItem.GetColumnHeaderItems();
Assert.AreEqual(1, headers.Length);
Assert.Equals((((ITableProvider)calendarAutomationPeer).GetColumnHeaders())[3], headers[0]);
Assert.IsNull(tableItem.GetRowHeaderItems());
#endregion
#region DayButtonAutomationPeer IGridItemProvider tests:
foreach (UIElement child in calendar.MonthControl.MonthView.Children)
{
int childRow = (int)child.GetValue(Grid.RowProperty);
IGridItemProvider gridItem;
if (childRow != 0)
{
peer = CalendarDayButtonAutomationPeer.CreatePeerForElement(child);
Assert.IsNotNull(peer);
gridItem = (IGridItemProvider)peer.GetPattern(PatternInterface.GridItem);
Assert.IsNotNull(gridItem);
Assert.AreEqual(child.GetValue(Grid.ColumnProperty), gridItem.Column);
Assert.AreEqual((int)child.GetValue(Grid.RowProperty) - 1, gridItem.Row);
Assert.AreEqual(1, gridItem.ColumnSpan);
Assert.AreEqual(1, gridItem.RowSpan);
Assert.AreEqual(calendarAutomationPeer, testPeer.GetPeerFromProvider(gridItem.ContainingGrid));
}
}
#endregion
});
EnqueueTestComplete();
}
public void Calendar_AutomationPeer()
{
Calendar calendar = new Calendar();
Assert.IsNotNull(calendar);
calendar.Height = 200;
calendar.Width = 200;
_isLoaded = false;
DateTime date = new DateTime(2000, 2, 2);
calendar.DisplayDate = date;
calendar.SelectedDate = date;
calendar.Loaded += new RoutedEventHandler(calendar_Loaded);
CalendarAutomationPeer peer = ((CalendarAutomationPeer)CalendarAutomationPeer.CreatePeerForElement(calendar));
Assert.IsNotNull(peer);
TestPeer testPeer = new TestPeer(calendar);
Assert.IsNotNull(testPeer);
TestPanel.Children.Add(calendar);
EnqueueConditional(IsLoaded);
EnqueueCallback(delegate
{
Assert.AreEqual(peer.GetAutomationControlType(), AutomationControlType.Calendar, "Incorrect Control type for calendar");
Assert.AreEqual(peer.GetClassName(), calendar.GetType().Name, "Incorrect ClassName value for Calendar");
Assert.AreEqual(peer.GetName(), date.ToString(), "Incorrect Name value for CalendarPeer");
Assert.IsTrue(peer.IsContentElement(), "Incorrect IsContentElement value");
Assert.IsTrue(peer.IsControlElement(), "Incorrect IsControlElement value");
#region CalendarAutomationPeer IGridProvider tests:
IGridProvider calendarGridProvider = ((IGridProvider)peer.GetPattern(PatternInterface.Grid));
Assert.IsNotNull(calendarGridProvider, "Incorrect calendarGridProvider value");
Assert.AreEqual(calendar.MonthControl.MonthView.RowDefinitions.Count - 1, calendarGridProvider.RowCount, "Incorrect RowCount value");
Assert.AreEqual(calendar.MonthControl.MonthView.ColumnDefinitions.Count, calendarGridProvider.ColumnCount, "Incorrect ColumnCount value");
IRawElementProviderSimple cell = calendarGridProvider.GetItem(0, 3);
Assert.IsNotNull(cell, "GetItem returned null for valid cell");
AutomationPeer cellPeer = testPeer.GetPeerFromProvider(cell);
Assert.AreEqual(typeof(CalendarDayButton).Name, cellPeer.GetClassName(), "GetItem did not return DayButton");
calendar.DisplayMode = CalendarMode.Year;
Assert.AreEqual(calendar.MonthControl.YearView.RowDefinitions.Count, calendarGridProvider.RowCount, "Incorrect RowCount value");
Assert.AreEqual(calendar.MonthControl.YearView.ColumnDefinitions.Count, calendarGridProvider.ColumnCount, "Incorrect ColumnCount value");
cell = calendarGridProvider.GetItem(2, 3);
Assert.IsNotNull(cell, "GetItem returned null for valid cell");
cellPeer = testPeer.GetPeerFromProvider(cell);
Assert.AreEqual(typeof(CalendarButton).Name, cellPeer.GetClassName(), "GetItem did not return CalendarButton");
calendar.DisplayMode = CalendarMode.Decade;
Assert.AreEqual(calendar.MonthControl.YearView.RowDefinitions.Count, calendarGridProvider.RowCount, "Incorrect RowCount value");
Assert.AreEqual(calendar.MonthControl.YearView.ColumnDefinitions.Count, calendarGridProvider.ColumnCount, "Incorrect ColumnCount value");
cell = calendarGridProvider.GetItem(2, 3);
Assert.IsNotNull(cell, "GetItem returned null for valid cell");
cellPeer = testPeer.GetPeerFromProvider(cell);
Assert.AreEqual(typeof(CalendarButton).Name, cellPeer.GetClassName(), "GetItem did not return CalendarButton");
cell = calendarGridProvider.GetItem(10, 10);
Assert.IsNull(cell, "GetItem returned object for invalid cell");
#endregion
#region CalendarAutomationPeer IMultipleViewProvider tests:
calendar._hasFocus = true;
IMultipleViewProvider calendarMultiViewProvider = ((IMultipleViewProvider)peer.GetPattern(PatternInterface.MultipleView));
Assert.IsNotNull(calendarMultiViewProvider);
Assert.IsTrue(calendarMultiViewProvider.CurrentView == (int)CalendarMode.Decade);
Assert.IsTrue(CalendarMode.Decade.ToString() == calendarMultiViewProvider.GetViewName(calendarMultiViewProvider.CurrentView));
calendarMultiViewProvider.SetCurrentView((int)CalendarMode.Year);
Assert.IsTrue(calendar.DisplayMode == CalendarMode.Year);
Assert.IsTrue(calendarMultiViewProvider.CurrentView == (int)CalendarMode.Year);
Assert.IsTrue(CalendarMode.Year.ToString() == calendarMultiViewProvider.GetViewName(calendarMultiViewProvider.CurrentView));
#endregion
#region CalendarAutomationPeer ISelectionProvider tests:
ISelectionProvider calendarSelectionProvider = ((ISelectionProvider)peer.GetPattern(PatternInterface.Selection));
Assert.IsNotNull(calendarSelectionProvider);
Assert.IsFalse(calendarSelectionProvider.IsSelectionRequired, "Incorrect IsSelectionRequired value");
Assert.IsFalse(calendarSelectionProvider.CanSelectMultiple, "Incorrect CanSelectMultiple value");
calendar.SelectionMode = CalendarSelectionMode.MultipleRange;
Assert.IsNull(calendar.SelectedDate);
Assert.IsTrue(calendarSelectionProvider.CanSelectMultiple, "Incorrect CanSelectMultiple value");
calendar.SelectedDates.AddRange(new DateTime(2000, 2, 10), new DateTime(2000, 3, 30));
IRawElementProviderSimple[] selection = calendarSelectionProvider.GetSelection();
Assert.IsNotNull(selection, "GetSelection returned null for valid selection");
Assert.AreEqual(selection.Length, 1, "GetSelection returned wrong number of selections");
cellPeer = testPeer.GetPeerFromProvider(selection[0]);
Assert.AreEqual(cellPeer.GetClassName(), typeof(CalendarButton).Name, "Incorrect name for CalendarButton");
calendar.DisplayMode = CalendarMode.Month;
selection = calendarSelectionProvider.GetSelection();
Assert.IsNotNull(selection, "GetSelection returned null for valid selection");
Assert.AreEqual(selection.Length, 31, "GetSelection returned wrong number of selections");
cellPeer = testPeer.GetPeerFromProvider(selection[0]);
Assert.AreEqual(cellPeer.GetClassName(), typeof(CalendarDayButton).Name, "Incorrect name for DayButton");
#endregion
#region CalendarAutomationPeer ITableProvider tests:
ITableProvider calendarTableProvider = ((ITableProvider)peer.GetPattern(PatternInterface.Table));
Assert.IsNotNull(calendarTableProvider);
Assert.AreEqual(calendarTableProvider.RowOrColumnMajor, RowOrColumnMajor.RowMajor, "Incorrect RowOrColumnMajor value");
IRawElementProviderSimple[] headers = calendarTableProvider.GetRowHeaders();
Assert.IsNull(headers, "GetRowHeaders should return null");
headers = calendarTableProvider.GetColumnHeaders();
Assert.IsNotNull(headers, "GetColumnHeaders returned null");
Assert.AreEqual(headers.Length, 7, "Incorrect number of column headers");
#endregion
});
EnqueueTestComplete();
}
