Beispiel #1
0
        public void NullsAreEqual()
        {
            var falseComparer = new DelegateEqualityComparer <ExampleClass>((c1, c2) => false);

            var result = falseComparer.Equals(null, null);

            Assert.That(result, Is.True);
        }
Beispiel #2
0
        public void SelfIsAlwaysEqualWithSelf()
        {
            var self          = new ExampleClass();
            var falseComparer = new DelegateEqualityComparer <ExampleClass>((c1, c2) => false);

            var result = falseComparer.Equals(self, self);

            Assert.That(result, Is.True);
        }
Beispiel #3
0
        public void NullWithNonNullIsAlwaysUnequal()
        {
            var otherClass   = new ExampleClass();
            var trueComparer = new DelegateEqualityComparer <ExampleClass>((c1, c2) => true);

            var result = trueComparer.Equals(null, otherClass);

            Assert.That(result, Is.False);
        }
        public void EqualsCallsTheProvidedDelegate()
        {
            var comparerWasCalled = false;

            Func<string, string, bool> comparer = (string x, string y) =>
            {
                comparerWasCalled = true;
                return true;
            };

            var sut = new DelegateEqualityComparer<string>(comparer, this.defaultHash);

            sut.Equals("test", "test");

            Assert.True(comparerWasCalled);
        }
Beispiel #5
0
        public void CanMakeEqualityTest()
        {
            var first = new ExampleClass {
                Number = 1, Word = "Hat"
            };
            var second = new ExampleClass {
                Number = 1, Word = "Sock"
            };
            var comparer = new DelegateEqualityComparer <ExampleClass>((c1, c2) => c1.Number == c2.Number);

            var defaultEquals = first == second;
            var result        = comparer.Equals(first, second);

            Assume.That(defaultEquals, Is.False);
            Assert.That(result, Is.True);
        }
Beispiel #6
0
        public static void AddRange <T, TSort, TEquality>(
            this ObservableCollection <T> target,
            IEnumerable <T> collection,
            Func <T, TSort> sortSelector,
            Func <T, TEquality> equalitySelector)
            where TSort : IComparable
        {
            var sortComparer = new DelegateComparer <T>(
                (x, y) => sortSelector(x).CompareTo(sortSelector(y)));
            var equalityComparer = new DelegateEqualityComparer <T>(
                (x, y) => equalitySelector(x).Equals(equalitySelector(y)));
            var index = target.Count - 1;

            foreach (var addItem in collection.OrderBy(sortSelector))
            {
                if (index < 0)
                {
                    target.Insert(0, addItem);
                }
                else
                {
                    while (index >= 0)
                    {
                        var currentItem = target[index];
                        if (sortComparer.Compare(currentItem, addItem) >= 0)
                        {
                            if (equalityComparer.Equals(currentItem, addItem) != true)
                            {
                                target.Insert(index + 1, addItem);
                            }
                            break;
                        }
                        index -= 1;
                    }
                }
            }
        }
        public void Equals_CompareEqualTwoIntegers_ReturnTrue()
        {
            var comparer = new DelegateEqualityComparer <int>((value1, value2) => value1 == value2);

            Assert.True(comparer.Equals(1234, 1234));
        }
        public void Equals_CompareNotEqualTwoIntegers_ReturnFalse()
        {
            var comparer = new DelegateEqualityComparer <int>((value1, value2) => value1 == value2);

            Assert.False(comparer.Equals(1234, 2345));
        }