/// <summary> /// Handles the <see cref="INotifyCollectionChanged.CollectionChanged"/> event of the /// master list of plugins. /// </summary> /// <remarks> /// This applies any changes that are made to the maser list to the transacted list /// with which we are currently working. /// </remarks> /// <param name="sender">The object that raised the event.</param> /// <param name="e">A <see cref="NotifyCollectionChangedEventArgs"/> describing the event arguments.</param> private void MasterPlugins_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e) { switch (e.Action) { case NotifyCollectionChangedAction.Add: foreach (Plugin plgAdded in e.NewItems) { m_ostActivePlugins.Add(plgAdded); } break; case NotifyCollectionChangedAction.Remove: foreach (Plugin plgRemoved in e.OldItems) { m_ostActivePlugins.Remove(plgRemoved); } break; case NotifyCollectionChangedAction.Replace: foreach (Plugin plgRemoved in e.OldItems) { m_ostActivePlugins.Remove(plgRemoved); } foreach (Plugin plgAdded in e.NewItems) { m_ostActivePlugins.Add(plgAdded); } break; case NotifyCollectionChangedAction.Reset: m_ostActivePlugins.Clear(); break; } }
public void ObserveSkilledPassiveNodesGeneratesCorrectValues() { var modifiers = CreateModifiers(6); var skilledNodes = CreateSkillNodes(3); var parseResults = CreateParseResults(modifiers); var expected = new[] { new CalculatorUpdate(modifiers, new Modifier[0]), new CalculatorUpdate(new Modifier[0], parseResults[0].Modifiers), new CalculatorUpdate(new Modifier[0], parseResults[1].Modifiers), }; var observableSet = new ObservableSet <SkillNode>(); var sut = CreateSut(MockSkilledPassiveNodeParser(parseResults)); var actual = new List <CalculatorUpdate>(); using (sut.ObserveSkilledPassiveNodes(observableSet).Subscribe(actual.Add)) { observableSet.UnionWith(skilledNodes); observableSet.Remove(skilledNodes[0]); observableSet.Remove(skilledNodes[1]); } Assert.AreEqual(expected, actual); }
/// <summary> /// Handles the <see cref="INotifyPropertyChanged.PropertyChanged"/> event of tasks. /// </summary> /// <remarks> /// This adds or removes tasks from the active task list as appropriate. /// </remarks> /// <param name="sender">The object that raised the event.</param> /// <param name="e">A <see cref="PropertyChangedEventArgs"/> describing the event arguments.</param> private void Task_PropertyChanged(object sender, PropertyChangedEventArgs e) { if (e.PropertyName.Equals(ObjectHelper.GetPropertyName <AddModTask>(x => x.IsActive))) { AddModTask tskTask = (AddModTask)sender; if (tskTask.IsActive) { m_setActiveTasks.Add(tskTask); } else { m_setActiveTasks.Remove(tskTask); } } if (e.PropertyName.Equals(ObjectHelper.GetPropertyName <AddModTask>(x => x.TaskSpeed))) { int speed = 0; Int64 progress = 0; Int64 maxprogress = 0; foreach (AddModTask Task in ActiveTasks) { speed += Task.TaskSpeed; progress += Task.ItemProgress; maxprogress += Task.ItemProgressMaximum; } TotalMaximumProgress = maxprogress; TotalProgress = progress; TotalSpeed = speed; } }
public void TestRemove() { ExpectCollectionChange(NotifyCollectionChangedAction.Remove, "item 2"); _set.Remove("item"); ExpectChangeCalls(0); _set.Remove("item 2"); ExpectChangeCalls(1); _set.Remove("item 2"); ExpectChangeCalls(0); }
public void TestRemove() { ExpectCollectionRemove("item 2"); _set.Remove("item"); ExpectChangeCalls(0); _set.Remove("item 2"); ExpectChangeCalls(1); _set.Remove("item 2"); ExpectChangeCalls(0); }
/// <summary> /// Handles the <see cref="INotifyPropertyChanged.PropertyChanged"/> event of tasks. /// </summary> /// <remarks> /// This adds or removes tasks from the active task list as appropriate. /// </remarks> /// <param name="sender">The object that raised the event.</param> /// <param name="e">A <see cref="PropertyChangedEventArgs"/> describing the event arguments.</param> private void Task_PropertyChanged(object sender, PropertyChangedEventArgs e) { if (e.PropertyName.Equals(ObjectHelper.GetPropertyName <IBackgroundTask>(x => x.IsActive))) { IBackgroundTask tskTask = (IBackgroundTask)sender; if (tskTask.IsActive) { m_setActiveTasks.Add(tskTask); } else { m_setActiveTasks.Remove(tskTask); } } }
public void TestRemove() { var list = new List <string> { "aaa", "bbb", "ccc" }; var set = new ObservableSet <string>(list); Assert.Equal(set.Count, list.Count); bool propertyChangedInvoked = false; bool collectionChangedInvoked = false; set.PropertyChanged += (sender, e) => { Assert.Equal(nameof(ObservableSet <string> .Count), e.PropertyName); propertyChangedInvoked = true; }; set.CollectionChanged += (sender, e) => { Assert.Equal(NotifyCollectionChangedAction.Remove, e.Action); Assert.Equal(1, e.OldStartingIndex); Assert.NotNull(e.OldItems); Assert.Equal(1, e.OldItems.Count); Assert.Equal("bbb", e.OldItems[0]); collectionChangedInvoked = true; }; set.Remove("bbb"); Assert.Equal(2, set.Count); Assert.Equal("aaa", set[0]); Assert.Equal("ccc", set[1]); Assert.True(propertyChangedInvoked); Assert.True(collectionChangedInvoked); }
public void remove_should_raise_propertychanged() { bool eventWasRaisedForCount = false; bool eventWasRaisedForIsEmpty = false; var observableSet = new ObservableSet <int> { 1, 2, 3 }; observableSet.PropertyChanged += (sender, args) => { sender.Should().Be.EqualTo(observableSet); if (args.PropertyName == ISEMPTY_PROPERTY_NAME) { eventWasRaisedForIsEmpty = true; } if (args.PropertyName == COUNT_PROPERTY_NAME) { eventWasRaisedForCount = true; } }; observableSet.Remove(1); eventWasRaisedForIsEmpty.Should().Be.True(); eventWasRaisedForCount.Should().Be.True(); }
///// <summary> ///// Given a collection, will move an item from the oldIndex to the newIndex. ///// </summary> //public void MoveItemTest(ObservableSet<string> collection, int oldIndex, int newIndex) //{ // INotifyPropertyChanged collectionPropertyChanged = collection; // collectionPropertyChanged.PropertyChanged += Collection_PropertyChanged; // _expectedPropertyChanged = new[] { new PropertyNameExpected(ITEMARRAY) }; // collection.CollectionChanged += Collection_CollectionChanged; // string itemAtOldIndex = collection[oldIndex]; // ExpectedCollectionChangedFired++; // ExpectedAction = NotifyCollectionChangedAction.Move; // ExpectedNewItems = new string[] { itemAtOldIndex }; // ExpectedNewStartingIndex = newIndex; // ExpectedOldItems = new string[] { itemAtOldIndex }; // ExpectedOldStartingIndex = oldIndex; // int expectedCount = collection.Count; // collection.Move(oldIndex, newIndex); // Assert.Equal(expectedCount, collection.Count); // Assert.Equal(itemAtOldIndex, collection[newIndex]); // Assert.Equal(ExpectedCollectionChangedFired, NumCollectionChangedFired); // foreach (var item in _expectedPropertyChanged) // Assert.True(item.IsFound, "The propertychanged event should have fired for" + item.Name + ", since we just moved an item"); // collection.CollectionChanged -= Collection_CollectionChanged; // collectionPropertyChanged.PropertyChanged -= Collection_PropertyChanged; //} ///// <summary> ///// Will set that new item at the specified index in the given collection. ///// </summary> //public void ReplaceItemTest(ObservableSet<string> collection, int index, string newItem) //{ // INotifyPropertyChanged collectionPropertyChanged = collection; // collectionPropertyChanged.PropertyChanged += Collection_PropertyChanged; // _expectedPropertyChanged = new[] { new PropertyNameExpected(ITEMARRAY) }; // collection.CollectionChanged += Collection_CollectionChanged; // string itemAtOldIndex = collection.ToArray()[index]; // ExpectedCollectionChangedFired++; // ExpectedAction = NotifyCollectionChangedAction.Replace; // ExpectedNewItems = new string[] { newItem }; // ExpectedNewStartingIndex = index; // ExpectedOldItems = new string[] { itemAtOldIndex }; // ExpectedOldStartingIndex = index; // int expectedCount = collection.Count; // collection[index] = newItem; // Assert.Equal(expectedCount, collection.Count); // Assert.Equal(newItem, collection[index]); // Assert.Equal(ExpectedCollectionChangedFired, NumCollectionChangedFired); // foreach (var item in _expectedPropertyChanged) // Assert.True(item.IsFound, "The propertychanged event should have fired for" + item.Name + ", since we just replaced an item"); // collection.CollectionChanged -= Collection_CollectionChanged; // collectionPropertyChanged.PropertyChanged -= Collection_PropertyChanged; //} /// <summary> /// Given a collection, index and item to remove, will try to remove that item /// from the index. If the item has duplicates, will verify that only the first /// instance was removed. /// </summary> public void RemoveItemTest(ObservableSet <string> collection, int itemIndex, string itemToRemove, bool isSuccessfulRemove, bool hasDuplicates) { INotifyPropertyChanged collectionPropertyChanged = collection; collectionPropertyChanged.PropertyChanged += Collection_PropertyChanged; _expectedPropertyChanged = new[] { new PropertyNameExpected(COUNT), //new PropertyNameExpected(ITEMARRAY) }; collection.CollectionChanged += Collection_CollectionChanged; if (isSuccessfulRemove) { ExpectedCollectionChangedFired++; } ExpectedAction = NotifyCollectionChangedAction.Remove; ExpectedNewItems = null; ExpectedNewStartingIndex = -1; ExpectedOldItems = new string[] { itemToRemove }; ExpectedOldStartingIndex = itemIndex; int expectedCount = isSuccessfulRemove ? collection.Count - 1 : collection.Count; bool removedItem = collection.Remove(itemToRemove); Assert.Equal(expectedCount, collection.Count); Assert.Equal(ExpectedCollectionChangedFired, NumCollectionChangedFired); if (isSuccessfulRemove) { foreach (var item in _expectedPropertyChanged) { Assert.True(item.IsFound, "The propertychanged event should have fired for" + item.Name + ", since there were items removed."); } Assert.True(removedItem, "Should have been successful in removing the item."); } else { foreach (var item in _expectedPropertyChanged) { Assert.False(item.IsFound, "The propertychanged event should have fired for" + item.Name + ", since there were no items removed."); } Assert.False(removedItem, "Should not have been successful in removing the item."); } if (hasDuplicates) { return; } Assert.DoesNotContain(itemToRemove, collection); collection.CollectionChanged -= Collection_CollectionChanged; collectionPropertyChanged.PropertyChanged -= Collection_PropertyChanged; }
public void remove_should_work() { var observableSet = new ObservableSet <int> { 1, 2, 3, 4, 5 }; observableSet.Remove(1); observableSet.Count.Should().Be.EqualTo(4); observableSet.Should().Have.SameSequenceAs(new[] { 2, 3, 4, 5 }); }
internal void UpdateAssetStatus(AssetViewModel asset) { if (asset.Sources.NeedUpdateFromSource && !asset.IsDeleted) { assetsToUpdate.Add(asset); } else { assetsToUpdate.Remove(asset); } UpdateAllAssetsWithModifiedSourceCommand.IsEnabled = assetsToUpdate.Count > 0; }
public void SetOperationsTest() { const int initialCount = 15; const int removeItems = 4; const int insertItems = 2; var items = new[] { 40, 63, 98, 20, 24, 76, 96, 53, 5, 11, 29, 12, 46, 59, 7, 45, 86, 91, 57, 95 }; var indexes = new[] { 6, 2, 5, 11, 0, 3, 13, 1 }; var originalSet = new HashSet <Person>(items.Take(initialCount).Select(x => new Person(x)), new PersonEqualityComparer()); var set = new ObservableSet <Person>(originalSet); var sorted = new SortedReadOnlyObservableList <Person>(set, (x, y) => x.Age.CompareTo(y.Age), new PersonEqualityComparer(), nameof(Person.Age)); Assert.AreEqual(initialCount, set.Count); Assert.AreEqual(initialCount, sorted.Count); Assert.IsTrue(items.Take(initialCount).Select(x => new Person(x)).OrderBy(p => p.Age).SequenceEqual(sorted, new PersonEqualityComparer())); foreach (var person in indexes.Take(removeItems).Select(i => new Person(items[i]))) { set.Remove(person); } Assert.AreEqual(initialCount - removeItems, set.Count); Assert.AreEqual(initialCount - removeItems, sorted.Count); Assert.IsTrue(originalSet.OrderBy(p => p.Age).SequenceEqual(sorted, new PersonEqualityComparer())); foreach (var person in items.Skip(initialCount).Take(insertItems).Select(x => new Person(x))) { set.Add(person); } Assert.AreEqual(initialCount - removeItems + insertItems, set.Count); Assert.AreEqual(initialCount - removeItems + insertItems, sorted.Count); Assert.IsTrue(originalSet.OrderBy(p => p.Age).SequenceEqual(sorted, new PersonEqualityComparer())); foreach (var result in indexes.Skip(removeItems) .Zip(items.Skip(initialCount + insertItems), (i, x) => new { OldItem = new Person(items[i]), NewItem = new Person(x) })) { set.SymmetricExceptWith(new[] { result.OldItem, result.NewItem }); } Assert.AreEqual(initialCount - removeItems + insertItems, set.Count); Assert.AreEqual(initialCount - removeItems + insertItems, sorted.Count); Assert.IsTrue(originalSet.OrderBy(p => p.Age).SequenceEqual(sorted, new PersonEqualityComparer())); set.Clear(); Assert.AreEqual(0, set.Count); Assert.AreEqual(0, sorted.Count); }
public void TestIndexOf() { var list = new List <string> { "aaa", "bbb", "ccc" }; var set = new ObservableSet <string>(list); Assert.Equal(set.IndexOf("aaa"), 0); Assert.Equal(set.IndexOf("bbb"), 1); Assert.Equal(set.IndexOf("ccc"), 2); Assert.Equal(set.IndexOf("ddd"), -1); set.Add("ddd"); Assert.Equal(set.IndexOf("ddd"), 3); set.Remove("bbb"); Assert.Equal(set.IndexOf("bbb"), -1); Assert.Equal(set.IndexOf("ddd"), 2); }
public void TestIndexOf() { var list = new List <string> { "aaa", "bbb", "ccc" }; var set = new ObservableSet <string>(list); Assert.Equal(0, set.IndexOf("aaa")); Assert.Equal(1, set.IndexOf("bbb")); Assert.Equal(2, set.IndexOf("ccc")); Assert.Equal(-1, set.IndexOf("ddd")); set.Add("ddd"); Assert.Equal(3, set.IndexOf("ddd")); set.Remove("bbb"); Assert.Equal(-1, set.IndexOf("bbb")); Assert.Equal(2, set.IndexOf("ddd")); }
public void SetOperationsTest() { var values = new[] { 15, 14, 89, 56, 8, 68, 17, 39, 31, 93, 78, 80, 87, 85, 57, 20, 6, 1 }; var people = new ObservableSet <Observable>(values.Select(x => new Observable(x)).ToList()); var transfList = new DynamicTransformingReadOnlyObservableList <Observable, int>(people, x => x.Subject); var copy = new TransformingReadOnlyObservableList <int, int>(transfList, x => x); Assert.AreEqual(people.Count, transfList.Count); Assert.IsTrue(new HashSet <int>(people.Select(x => x.Prop)).SetEquals(transfList)); Assert.IsTrue(new HashSet <int>(people.Select(x => x.Prop)).SetEquals(copy)); people.Add(new Observable(19)); people.First().Prop = 82; people.Remove(people.Last()); Assert.AreEqual(people.Count, transfList.Count); Assert.IsTrue(new HashSet <int>(people.Select(x => x.Prop)).SetEquals(transfList)); Assert.IsTrue(new HashSet <int>(people.Select(x => x.Prop)).SetEquals(copy)); }
public void remove_should_raise_collectionchanged() { bool eventWasRaised = false; var observableSet = new ObservableSet <int> { 1, 2, 3 }; observableSet.CollectionChanged += (sender, args) => { sender.Should().Be.EqualTo(observableSet); args.Action.Should().Be.EqualTo( NotifyCollectionChangedAction.Remove); args.OldItems[0].Should().Be.EqualTo(2); args.OldStartingIndex.Should().Be.EqualTo(1); eventWasRaised = true; }; observableSet.Remove(2); eventWasRaised.Should().Be.True(); }
public void ObserveSkillsGeneratesCorrectValues() { var modifiers = CreateModifiers(6); var skills = CreateSkills(); var parseResults = CreateParseResults(modifiers); var expected = new[] { new CalculatorUpdate(parseResults[0].Modifiers, new Modifier[0]), new CalculatorUpdate(new Modifier[0], parseResults[0].Modifiers), }; var parser = MockSkillParser(skills, parseResults); var sut = CreateSut(parser); var observableCollection = new ObservableSet <IReadOnlyList <Skill> >(); var actual = new List <CalculatorUpdate>(); using (sut.ObserveSkills(observableCollection).Subscribe(actual.Add)) { observableCollection.Add(skills[0]); observableCollection.Remove(skills[0]); } Assert.AreEqual(expected, actual); }
public void TestRemove() { var list = new List<string> { "aaa", "bbb", "ccc" }; var set = new ObservableSet<string>(list); Assert.AreEqual(set.Count, list.Count); bool propertyChangedInvoked = false; bool collectionChangedInvoked = false; set.PropertyChanged += (sender, e) => { Assert.AreEqual(e.PropertyName, nameof(ObservableSet<string>.Count)); propertyChangedInvoked = true; }; set.CollectionChanged += (sender, e) => { Assert.AreEqual(e.Action, NotifyCollectionChangedAction.Remove); Assert.AreEqual(e.OldStartingIndex, 1); Assert.NotNull(e.OldItems); Assert.AreEqual(e.OldItems.Count, 1); Assert.AreEqual(e.OldItems[0], "bbb"); collectionChangedInvoked = true; }; set.Remove("bbb"); Assert.AreEqual(set.Count, 2); Assert.AreEqual(set[0], "aaa"); Assert.AreEqual(set[1], "ccc"); Assert.True(propertyChangedInvoked); Assert.True(collectionChangedInvoked); }
public void TestIndexOf() { var list = new List<string> { "aaa", "bbb", "ccc" }; var set = new ObservableSet<string>(list); Assert.AreEqual(set.IndexOf("aaa"), 0); Assert.AreEqual(set.IndexOf("bbb"), 1); Assert.AreEqual(set.IndexOf("ccc"), 2); Assert.AreEqual(set.IndexOf("ddd"), -1); set.Add("ddd"); Assert.AreEqual(set.IndexOf("ddd"), 3); set.Remove("bbb"); Assert.AreEqual(set.IndexOf("bbb"), -1); Assert.AreEqual(set.IndexOf("ddd"), 2); }