Exemple #1
0
            public void AllowsNullValues()
            {
                var observableDictionary = new FastObservableDictionary <int, object>();

                observableDictionary.Add(1, null);

                Assert.IsNull(observableDictionary[1]);
            }
Exemple #2
0
            public void ReturnsValueFromValidKey()
            {
                var observableDictionary = new FastObservableDictionary <int, int>
                {
                    {
                        1, 1
                    }
                };

                var success = observableDictionary.TryGetValue(1, out int value);

                Assert.IsTrue(success && value == 1);
            }
Exemple #3
0
            public void ReturnsCustomComparer()
            {
                var customComparer = StringComparer.OrdinalIgnoreCase;

                var observableDictionary = new FastObservableDictionary <string, int>(customComparer)
                {
                    {
                        "1", 1
                    }
                };

                Assert.AreEqual(customComparer, observableDictionary.Comparer);
            }
Exemple #4
0
            public void ReturnsNullForInvalidTypedObject()
            {
                var observableDictionary = new FastObservableDictionary <int, int>()
                {
                    {
                        1, 1
                    }
                };

                var result = observableDictionary[(object)"1"];

                Assert.IsNull(result);
            }
Exemple #5
0
            public void ReturnsDefaultComparer()
            {
                var defaultComparer = EqualityComparer <int> .Default;

                var observableDictionary = new FastObservableDictionary <int, int>()
                {
                    {
                        1, 1
                    }
                };

                Assert.AreEqual(defaultComparer, observableDictionary.Comparer);
            }
Exemple #6
0
            public void ContainsObjectInvalidTypeFalse()
            {
                var observableDictionary = new FastObservableDictionary <int, int>()
                {
                    {
                        1, 2
                    }
                };

                var result = observableDictionary.Contains((object)"1");

                Assert.IsFalse(result);
            }
Exemple #7
0
            public void ContainsKeyFalse()
            {
                var observableDictionary = new FastObservableDictionary <int, int>()
                {
                    {
                        1, 1
                    }
                };

                var success = observableDictionary.ContainsKey(2);

                Assert.IsFalse(success);
            }
Exemple #8
0
            public void ContainsObjectTrue()
            {
                var observableDictionary = new FastObservableDictionary <int, int>()
                {
                    {
                        1, 2
                    }
                };

                var result = observableDictionary.Contains((object)1);

                Assert.IsTrue(result);
            }
Exemple #9
0
            public void ContainsKvpSuccess()
            {
                var observableDictionary = new FastObservableDictionary <int, int>()
                {
                    {
                        1, 2
                    }
                };

                var result = observableDictionary.Contains(new KeyValuePair <int, int>(1, 2));

                Assert.IsTrue(result);
            }
Exemple #10
0
            public void ReturnsDefaultFromInvalidKey()
            {
                var observableDictionary = new FastObservableDictionary <int, int>
                {
                    {
                        1, 1
                    }
                };

                var success = observableDictionary.TryGetValue(2, out int value);

                Assert.IsTrue(!success && value == 0);
            }
Exemple #11
0
            public void RaiseEventWhileRemovingStronglyTyped()
            {
                var counter = 1;
                var observableDictionary = new FastObservableDictionary <int, int>
                {
                    {
                        1, 1
                    }
                };

                observableDictionary.AutomaticallyDispatchChangeNotifications = false;
                observableDictionary.CollectionChanged += (sender, args) => counter--;

                observableDictionary.Remove(1);
                Assert.AreEqual(0, counter);
            }
Exemple #12
0
            public void RaisesEventWhileClearing()
            {
                bool wasRaised            = false;
                var  observableDictionary = new FastObservableDictionary <int, int>
                {
                    {
                        1, 1
                    }
                };

                observableDictionary.AutomaticallyDispatchChangeNotifications = false;
                observableDictionary.CollectionChanged += (sender, args) => wasRaised = args.Action == NotifyCollectionChangedAction.Reset;

                observableDictionary.Clear();

                Assert.IsTrue(wasRaised && observableDictionary.Count == 0);
            }
Exemple #13
0
            public void RaisesEventWhileUpdatingStronglyTyped()
            {
                var isUpdated            = false;
                var observableDictionary = new FastObservableDictionary <int, int>()
                {
                    {
                        1, 1
                    }
                };

                observableDictionary.AutomaticallyDispatchChangeNotifications = false;
                observableDictionary.CollectionChanged += (sender, args) => isUpdated = args.Action == NotifyCollectionChangedAction.Replace;

                observableDictionary[1] = 3;

                Assert.IsTrue(isUpdated);
            }
Exemple #14
0
            public void PopulatesKvpArray()
            {
                KeyValuePair <int, int>[] arr = new KeyValuePair <int, int> [2];

                var observableDictionary = new FastObservableDictionary <int, int>()
                {
                    {
                        1, 1
                    },
                    {
                        2, 2
                    }
                };

                observableDictionary.CopyTo(arr, 0);

                Assert.IsTrue(arr.Length == 2);
            }
Exemple #15
0
            public void RaisesEventWhileAddingStronglyTyped()
            {
                var counter = 0;
                var observableDictionary = new FastObservableDictionary <int, int>();

                observableDictionary.AutomaticallyDispatchChangeNotifications = false;
                observableDictionary.CollectionChanged += (sender, args) => counter++;

                observableDictionary[1] = 1;
                Assert.AreEqual(1, counter);

                observableDictionary[2] = 2;
                Assert.AreEqual(2, counter);

                observableDictionary[3] = 3;
                Assert.AreEqual(3, counter);

                observableDictionary[4] = 4;
                Assert.AreEqual(4, counter);
            }
Exemple #16
0
            public void RaisesEventWhileAddingObject()
            {
                var counter = 0;
                var observableDictionary = new FastObservableDictionary <int, int>();

                observableDictionary.AutomaticallyDispatchChangeNotifications = false;
                observableDictionary.CollectionChanged += (sender, args) => counter++;

                observableDictionary.Add((object)1, (object)1);
                Assert.AreEqual(1, counter);

                observableDictionary.Add((object)2, (object)2);
                Assert.AreEqual(2, counter);

                observableDictionary.Add((object)3, (object)3);
                Assert.AreEqual(3, counter);

                observableDictionary.Add((object)4, (object)4);
                Assert.AreEqual(4, counter);
            }
Exemple #17
0
            public void RaisesEventWhileAddingKvp()
            {
                var counter = 0;
                var observableDictionary = new FastObservableDictionary <int, int>();

                observableDictionary.AutomaticallyDispatchChangeNotifications = false;
                observableDictionary.CollectionChanged += (sender, args) => counter++;

                observableDictionary.Add(new KeyValuePair <int, int>(1, 1));
                Assert.AreEqual(1, counter);

                observableDictionary.Add(new KeyValuePair <int, int>(2, 2));
                Assert.AreEqual(2, counter);

                observableDictionary.Add(new KeyValuePair <int, int>(3, 3));
                Assert.AreEqual(3, counter);

                observableDictionary.Add(new KeyValuePair <int, int>(4, 4));
                Assert.AreEqual(4, counter);
            }
Exemple #18
0
            public void ThrowsArgumentNullExceptionForNullKey()
            {
                var observableDictionary = new FastObservableDictionary <object, int>();

                Assert.That(() => observableDictionary.Add(null, 1), Throws.ArgumentNullException);
            }
Exemple #19
0
            public void ThrowsArgumentNullExceptionForAddObject()
            {
                var observableDictionary = new FastObservableDictionary <int, int>();

                Assert.That(() => observableDictionary.Add(1, null), Throws.ArgumentNullException);
            }
Exemple #20
0
            public void ThrowsInvalidCastExceptionForAddObject()
            {
                var observableDictionary = new FastObservableDictionary <int, int>();

                Assert.That(() => observableDictionary.Add((object)"1", 1), Throws.TypeOf <InvalidCastException>());
            }