public void First_Tab_Should_Be_Selected_By_Default()
{
var items = new[]
{
new TabItem
{
Name = "first"
},
new TabItem
{
Name = "second"
},
};
var target = new TabStrip
{
Template = new FuncControlTemplate<TabStrip>(CreateTabStripTemplate),
Items = items,
};
target.ApplyTemplate();
Assert.Equal(0, target.SelectedIndex);
Assert.Same(items[0], target.SelectedItem);
}
public override Collection<CustomAttributeBuilder> GetCustomAttributes()
{
PropertyInfo[] props = new[]
{
typeof(EasyTableAttribute).GetProperty("TableName"),
typeof(EasyTableAttribute).GetProperty("Id"),
typeof(EasyTableAttribute).GetProperty("MobileAppUri"),
typeof(EasyTableAttribute).GetProperty("ApiKey"),
};
object[] propValues = new[]
{
TableName,
Id,
MobileAppUri,
ApiKey
};
ConstructorInfo constructor = typeof(EasyTableAttribute).GetConstructor(System.Type.EmptyTypes);
return new Collection<CustomAttributeBuilder>
{
new CustomAttributeBuilder(constructor, new object[] { }, props, propValues)
};
}
public void Clearing_IsSelected_And_Raising_IsSelectedChanged_On_Item_Should_Update_Selection()
{
var items = new[]
{
new Item(),
new Item(),
};
var target = new SelectingItemsControl
{
Items = items,
Template = this.Template(),
};
target.ApplyTemplate();
target.SelectedItem = items[1];
Assert.False(items[0].IsSelected);
Assert.True(items[1].IsSelected);
items[1].IsSelected = false;
items[1].RaiseEvent(new RoutedEventArgs(SelectingItemsControl.IsSelectedChangedEvent));
Assert.Equal(-1, target.SelectedIndex);
Assert.Null(target.SelectedItem);
}
public void ColumnsReadOnly()
{
var ints = new[] { new[] { 1, 2 }, new[] { 3, 4 }, new[] { 5, 6 } };
var view = new Lists2DTransposedView(ints);
Assert.AreEqual(false, view[0].GetProperties()[0].IsReadOnly);
Assert.AreEqual(false, view[0].GetProperties()[1].IsReadOnly);
Assert.AreEqual(false, view[0].GetProperties()[2].IsReadOnly);
Assert.AreEqual(false, view[1].GetProperties()[0].IsReadOnly);
Assert.AreEqual(false, view[1].GetProperties()[1].IsReadOnly);
Assert.AreEqual(false, view[1].GetProperties()[2].IsReadOnly);
ints = new[] { new[] { 1 }, new[] { 3, 4 }, new[] { 5, 6 } };
view = new Lists2DTransposedView(ints);
Assert.AreEqual(true, view[0].GetProperties()[0].IsReadOnly);
Assert.AreEqual(false, view[0].GetProperties()[1].IsReadOnly);
Assert.AreEqual(false, view[0].GetProperties()[2].IsReadOnly);
Assert.AreEqual(true, view[1].GetProperties()[0].IsReadOnly);
Assert.AreEqual(false, view[1].GetProperties()[1].IsReadOnly);
Assert.AreEqual(false, view[1].GetProperties()[2].IsReadOnly);
ints = new[] { new[] { 1 }, new[] { 3 }, new[] { 5, 6 } };
view = new Lists2DTransposedView(ints);
Assert.AreEqual(true, view[0].GetProperties()[0].IsReadOnly);
Assert.AreEqual(true, view[0].GetProperties()[1].IsReadOnly);
Assert.AreEqual(false, view[0].GetProperties()[2].IsReadOnly);
Assert.AreEqual(true, view[1].GetProperties()[0].IsReadOnly);
Assert.AreEqual(true, view[1].GetProperties()[1].IsReadOnly);
Assert.AreEqual(false, view[1].GetProperties()[2].IsReadOnly);
}
public void Clearing_SelectedIndex_Should_Raise_SelectionChanged_Event()
{
var items = new[]
{
new Item(),
new Item(),
};
var target = new SelectingItemsControl
{
Items = items,
Template = Template(),
SelectedIndex = 1,
};
var called = false;
target.SelectionChanged += (s, e) =>
{
Assert.Same(items[1], e.RemovedItems.Cast<object>().Single());
Assert.Empty(e.AddedItems);
called = true;
};
target.ApplyTemplate();
target.Presenter.ApplyTemplate();
target.SelectedIndex = -1;
Assert.True(called);
}
public void CustomAggregatorAccumulateTypeCalculate()
{
var names = new[] {"Paul", "Jackie", "Tom"};
var aggregator = names.AsBindable().Aggregate(0, (i, name) => i + name.Length);
var eventCatcher = new PropertyEventMonitor(aggregator);
Assert.AreEqual(4 + 6 + 3, aggregator.Current);
Assert.AreEqual(1, eventCatcher.Count);
}
public TopMenuViewModel()
{
TopMenuItemViewModel financials = CreateMenuItem("Financials");
TopMenuItemViewModel labor = CreateMenuItem("Labor");
var items = new[] {financials, labor};
MenuItems = new ObservableCollection<TopMenuItemViewModel>(items);
}
public void ReturnsTrueForEqualCollectionsWithSameObjectReferences()
{
var obj = new { Name = "test" };
var collection1 = new Collection<object>(new object[] { obj });
var collection2 = new Collection<object>(new object[] { obj });
Assert.IsTrue(CollectionHelper.IsEqualTo(collection1, collection2));
}
public void ConstructorShouldCopyProvidedSequence()
{
var expected = new []{ new object(), new object(), new object() };
var actual = new PagedCollection<object>( expected, 3 );
Assert.True( actual.SequenceEqual( expected ) );
actual = new PagedCollection<object>( new ObservableCollection<object>( expected ), 3 );
Assert.True( actual.SequenceEqual( expected ) );
}
public void EditTransposed(int r, int c, int value)
{
var ints = new[] { new[] { 1, 2 }, new[] { 3, 4 }, new[] { 5, 6 } };
var view = new Lists2DTransposedView(ints);
var row = view[r];
var property = row.GetProperties()[c];
property.SetValue(row, value);
Assert.AreEqual(value, ints[c][r]);
Assert.AreEqual(value, property.GetValue(row));
}
public void StringTwoNewLineChars_AddEachLineToCollection_CollecionContainsThreeExpectedLines()
{
const string input = "Lorem Ipsum\nSecond line\nThird line.";
var expected = new[] {"Lorem Ipsum", "Second line", "Third line."};
var actual = new Collection<string>();
input.EachLine(actual.Add);
Assert.Equal(expected, actual);
}
public void Add(ReferenceHandling referenceHandling)
{
var source = new ObservableCollection<WithGetReadOnlyPropertySealed<int>>();
var target = new ObservableCollection<WithGetReadOnlyPropertySealed<int>>();
using (Synchronize.PropertyValues(source, target, referenceHandling))
{
source.Add(new WithGetReadOnlyPropertySealed<int>(1));
var expected = new[] { new WithGetReadOnlyPropertySealed<int>(1) };
CollectionAssert.AreEqual(expected, source);
CollectionAssert.AreEqual(expected, target);
Assert.AreSame(source[0], target[0]);
}
}
public void CreateAndDisposeWhenTargetIsNotEmptyStructural()
{
var source = new ObservableCollection<WithGetReadOnlyPropertySealed<int>> { new WithGetReadOnlyPropertySealed<int>(1), new WithGetReadOnlyPropertySealed<int>(2) };
var target = new ObservableCollection<WithGetReadOnlyPropertySealed<int>> { new WithGetReadOnlyPropertySealed<int>(1), new WithGetReadOnlyPropertySealed<int>(2) };
using (Synchronize.PropertyValues(source, target, ReferenceHandling.Structural))
{
var expected = new[] { new WithGetReadOnlyPropertySealed<int>(1), new WithGetReadOnlyPropertySealed<int>(2) };
CollectionAssert.AreEqual(expected, source);
CollectionAssert.AreEqual(expected, target);
}
source.Add(new WithGetReadOnlyPropertySealed<int>(3));
CollectionAssert.AreEqual(new[] { new WithGetReadOnlyPropertySealed<int>(1), new WithGetReadOnlyPropertySealed<int>(2), new WithGetReadOnlyPropertySealed<int>(3) }, source);
CollectionAssert.AreEqual(new[] { new WithGetReadOnlyPropertySealed<int>(1), new WithGetReadOnlyPropertySealed<int>(2) }, target);
}
public void CreateAndDispose(ReferenceHandling referenceHandling)
{
var source = new ObservableCollection<int> { 1, 2 };
var target = new ObservableCollection<int>();
using (Synchronize.PropertyValues(source, target, referenceHandling))
{
var expected = new[] { 1, 2 };
CollectionAssert.AreEqual(expected, source);
CollectionAssert.AreEqual(expected, target);
}
source.Add(3);
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, source);
CollectionAssert.AreEqual(new[] { 1, 2 }, target);
}
public void SelectedIndex_Should_Initially_Be_Minus_1()
{
var items = new[]
{
new Item(),
new Item(),
};
var target = new SelectingItemsControl
{
Items = items,
Template = Template(),
};
Assert.Equal(-1, target.SelectedIndex);
}
public void CreateAndDisposeWhenTargetIsEmpty(ReferenceHandling referenceHandling)
{
var source = new ObservableCollection<WithGetReadOnlyPropertySealed<int>> { new WithGetReadOnlyPropertySealed<int>(1), new WithGetReadOnlyPropertySealed<int>(2) };
var target = new ObservableCollection<WithGetReadOnlyPropertySealed<int>>();
using (Synchronize.PropertyValues(source, target, referenceHandling))
{
var expected = new[] { new WithGetReadOnlyPropertySealed<int>(1), new WithGetReadOnlyPropertySealed<int>(2) };
CollectionAssert.AreEqual(expected, source);
CollectionAssert.AreEqual(expected, target);
Assert.AreSame(source[0], target[0]);
Assert.AreSame(source[1], target[1]);
}
source.Add(new WithGetReadOnlyPropertySealed<int>(3));
CollectionAssert.AreEqual(new[] { new WithGetReadOnlyPropertySealed<int>(1), new WithGetReadOnlyPropertySealed<int>(2), new WithGetReadOnlyPropertySealed<int>(3) }, source);
CollectionAssert.AreEqual(new[] { new WithGetReadOnlyPropertySealed<int>(1), new WithGetReadOnlyPropertySealed<int>(2) }, target);
}
public void MemberSelector_Should_Set_DataContext()
{
var items = new[] { new Item("Foo"), new Item("Bar") };
var target = new ItemsPresenter
{
Items = items,
MemberSelector = new FuncMemberSelector<Item, string>(x => x.Value),
};
target.ApplyTemplate();
var dataContexts = target.Panel.Children
.Cast<TextBlock>()
.Select(x => x.DataContext)
.ToList();
Assert.Equal(new[] { "Foo", "Bar" }, dataContexts);
}
public void Array2DTransposed()
{
var array = new[,] { { 1, 2 }, { 3, 4 }, { 5, 6 } };
var dataGrid = new DataGrid();
dataGrid.SetValue(ItemsSource.Array2DTransposedProperty, array);
dataGrid.Initialize();
Assert.IsInstanceOf<Array2DView>(dataGrid.ItemsSource);
Assert.AreEqual(3, dataGrid.Columns.Count);
Assert.AreEqual(2, dataGrid.Items.Count);
Assert.AreEqual(1, dataGrid.GetCellValue(0, 0));
Assert.AreEqual(3, dataGrid.GetCellValue(0, 1));
Assert.AreEqual(5, dataGrid.GetCellValue(0, 2));
Assert.AreEqual(2, dataGrid.GetCellValue(1, 0));
Assert.AreEqual(4, dataGrid.GetCellValue(1, 1));
Assert.AreEqual(6, dataGrid.GetCellValue(1, 2));
}
/// <summary>
/// Create collection of default stream handler factories.
/// </summary>
/// <returns>
/// Collection containing default stream handler factories.
/// </returns>
public static Collection<ISensorStreamHandlerFactory> CreateDefaultStreamHandlerFactories()
{
var streamHandlerTypes = new[]
{
StreamHandlerType.Interaction,
StreamHandlerType.Skeleton,
StreamHandlerType.BackgroundRemoval,
StreamHandlerType.SensorStatus
};
var factoryCollection = new Collection<ISensorStreamHandlerFactory>();
foreach (var type in streamHandlerTypes)
{
factoryCollection.Add(new SensorStreamHandlerFactory(type));
}
return factoryCollection;
}
public void Item_IsSelected_Should_Initially_Be_False()
{
var items = new[]
{
new Item(),
new Item(),
};
var target = new SelectingItemsControl
{
Items = items,
Template = Template(),
};
target.ApplyTemplate();
Assert.False(items[0].IsSelected);
Assert.False(items[1].IsSelected);
}
public void CreateFromArrays()
{
var ints = new[] { new[] { 1, 2 }, new[] { 3, 4 }, new[] { 5, 6 } };
var view = new Lists2DTransposedView(ints);
Assert.AreEqual(2, view.Count);
Assert.AreEqual(0, view[0].Index);
Assert.AreEqual(3, view[0].Count);
Assert.AreEqual(1, view[0].GetProperties()[0].GetValue(view[0]));
Assert.AreEqual(3, view[0].GetProperties()[1].GetValue(view[0]));
Assert.AreEqual(5, view[0].GetProperties()[2].GetValue(view[0]));
Assert.AreEqual(1, view[1].Index);
Assert.AreEqual(3, view[1].Count);
Assert.AreEqual(2, view[1].GetProperties()[0].GetValue(view[1]));
Assert.AreEqual(4, view[1].GetProperties()[1].GetValue(view[1]));
Assert.AreEqual(6, view[1].GetProperties()[2].GetValue(view[1]));
}
public void Setting_SelectedItem_Before_ApplyTemplate_Should_Set_Item_IsSelected_True()
{
var items = new[]
{
new Item(),
new Item(),
};
var target = new SelectingItemsControl
{
Items = items,
Template = Template(),
};
target.SelectedItem = items[1];
target.ApplyTemplate();
Assert.False(items[0].IsSelected);
Assert.True(items[1].IsSelected);
}
public ViewModel()
{
var names = new[] { "Tom", "Dick", "Mary" };
All = (from name in names
select new CheckRecordViewModel(name)).ToArray();
Selected = new ObservableCollection<CheckRecordViewModel>();
Messenger.Default.Register<CheckRecordViewModel>(this, record =>
{
if (record.IsSelected)
{
Selected.Add(record);
}
else
{
Selected.Remove(record);
}
});
}
public void Dispose_TracesAndInvokesInnerDisposeWhenControllerIsDisposable()
{
// Arrange
var mockController = new Mock<IHttpController>();
var mockDisposable = mockController.As<IDisposable>();
var request = new HttpRequestMessage();
var traceWriter = new TestTraceWriter();
var tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
var expectedTraces = new[]
{
new TraceRecord(request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "Dispose" },
new TraceRecord(request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "Dispose" }
};
// Act
((IDisposable)tracer).Dispose();
// Assert
Assert.Equal(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
mockDisposable.Verify(d => d.Dispose(), Times.Once());
}
public void Data_Of_Non_IHeadered_Items_Should_Be_Used()
{
var items = new[]
{
"foo",
"bar"
};
var target = new TabStrip
{
Template = new FuncControlTemplate<TabStrip>(CreateTabStripTemplate),
Items = items,
};
target.ApplyTemplate();
var result = target.GetLogicalChildren()
.OfType<TabStripItem>()
.Select(x => x.Content)
.ToList();
Assert.Equal(new[] { "foo", "bar" }, result);
}
public void Logical_Children_Should_Be_TabItems()
{
var items = new[]
{
new TabItem
{
Content = "foo"
},
new TabItem
{
Content = "bar"
},
};
var target = new TabControl
{
Template = new FuncControlTemplate<TabControl>(CreateTabControlTemplate),
Items = items,
};
Assert.Equal(items, target.GetLogicalChildren());
target.ApplyTemplate();
Assert.Equal(items, target.GetLogicalChildren());
}
public void ObjectBrowserSearchTextTest() {
using (var app = new VisualStudioApp()) {
var project = app.OpenProject(@"TestData\ObjectBrowser.sln");
System.Threading.Thread.Sleep(1000);
app.OpenObjectBrowser();
var objectBrowser = app.ObjectBrowser;
objectBrowser.EnsureLoaded();
// Initially, we should have only the top-level collapsed node for the project
int nodeCount = objectBrowser.TypeBrowserPane.Nodes.Count;
Assert.AreEqual(1, nodeCount, "Node count: " + nodeCount.ToString());
objectBrowser.TypeBrowserPane.Nodes[0].ExpandCollapse();
System.Threading.Thread.Sleep(1000);
// Now that it is expanded, we should also get a node for Program.py
nodeCount = objectBrowser.TypeBrowserPane.Nodes.Count;
Assert.AreEqual(2, nodeCount, "Node count: " + nodeCount.ToString());
objectBrowser.TypeBrowserPane.Nodes[1].ExpandCollapse();
System.Threading.Thread.Sleep(1000);
// Sanity-check the starting view with all nodes expanded.
var expectedNodesBeforeSearch = new[] {
new NodeInfo("ObjectBrowser", "ObjectBrowser"),
new NodeInfo("Program.py", "Program.py", new[] { "frob()" }),
new NodeInfo("Oar", "class Oar", new[] { "oar(self)" }),
new NodeInfo("Fob", "class Fob"),
new NodeInfo("FobOarBaz", "class FobOarBaz", new[] { "frob(self)" }),
};
AssertNodes(objectBrowser, expectedNodesBeforeSearch);
// Do the search and check results
objectBrowser.SearchText.SetValue("oar");
System.Threading.Thread.Sleep(1000);
objectBrowser.SearchButton.Click();
System.Threading.Thread.Sleep(1000);
var expectedNodesAfterSearch = new[] {
new NodeInfo("oar", "def oar(self)"),
new NodeInfo("Oar", "class Oar", new[] { "oar(self)" }),
new NodeInfo("FobOarBaz", "class FobOarBaz", new[] { "frob(self)" }),
};
AssertNodes(objectBrowser, expectedNodesAfterSearch);
// Clear the search and check that we get back to the starting view.
objectBrowser.ClearSearchButton.Click();
System.Threading.Thread.Sleep(1000);
AssertNodes(objectBrowser, expectedNodesBeforeSearch);
}
}
public void Setting_SelectedItem_To_Not_Present_Item_Should_Clear_Selection()
{
var items = new[]
{
new Item(),
new Item(),
};
var target = new SelectingItemsControl
{
Items = items,
Template = this.Template(),
};
target.ApplyTemplate();
target.SelectedItem = items[1];
Assert.Equal(items[1], target.SelectedItem);
Assert.Equal(1, target.SelectedIndex);
target.SelectedItem = new Item();
Assert.Equal(null, target.SelectedItem);
Assert.Equal(-1, target.SelectedIndex);
}
public void Setting_SelectedItem_Should_Set_SelectedIndex()
{
var items = new[]
{
new Item(),
new Item(),
};
var target = new SelectingItemsControl
{
Items = items,
Template = this.Template(),
};
target.ApplyTemplate();
target.SelectedItem = items[1];
Assert.Equal(items[1], target.SelectedItem);
Assert.Equal(1, target.SelectedIndex);
}
public void Header_Of_IHeadered_Items_Should_Be_Used()
{
var items = new[]
{
#pragma warning disable CS0252 // Possible unintended reference comparison; left hand side needs cast
Mock.Of<IHeadered>(x => x.Header == "foo"),
Mock.Of<IHeadered>(x => x.Header == "bar"),
#pragma warning restore CS0252 // Possible unintended reference comparison; left hand side needs cast
};
var target = new TabStrip
{
Template = new FuncControlTemplate<TabStrip>(CreateTabStripTemplate),
Items = items,
};
target.ApplyTemplate();
target.Presenter.ApplyTemplate();
var result = target.GetLogicalChildren()
.OfType<TabStripItem>()
.Select(x => x.Content)
.ToList();
Assert.Equal(new[] { "foo", "bar" }, result);
}
