Ejemplo n.º 1
0
            public void ReplaceChild(int ordinal, NodeHandle original, NodeHandle value)
            {
                Assert(_ltype != LockType.Read, "Node is currently read-only");
                Assert(ordinal >= 0 && ordinal < _count, "Index out of range.");
                Element replacing = _list[ordinal];

                Assert(
                    (original == null && replacing.ChildNode == null) ||
                    (original != null && original.Equals(replacing.ChildNode))
                    , "Incorrect child being replaced.");
                _list[ordinal] = new Element(replacing.Key, value);
            }
Ejemplo n.º 2
0
        public void Untyped_EqualAndDifferentNodes_CompareInExpectedOrder()
        {
            using (var set = new NodeSet())
            {
                NodeHandle
                    a = set.Create <TestNode>(),
                    b = set.Create <TestNode>(),
                    c = set.Create <TestNode2>();

                // Cannot compact following statements into reused functions,
                // because they are subtly different and generic rules impact
                // function overloads and availability

                // Compare equal type and instance
                Assert.AreEqual(a, a);
#pragma warning disable 1718  // comparison to same variable
                Assert.IsTrue(a == a);
#pragma warning restore 1718
                Assert.IsTrue(a.Equals(a));
                Assert.IsTrue(((object)a).Equals(a));
                Assert.IsTrue(a.Equals((object)a));

                // Compare LR equal type and non-equal instance
                Assert.AreNotEqual(a, b);
                Assert.IsFalse(a == b);
                Assert.IsFalse(a.Equals(b));
                Assert.IsFalse(((object)a).Equals(b));
                Assert.IsFalse(a.Equals((object)b));

                // Compare RL equal type and non-equal instance
                Assert.AreNotEqual(b, a);
                Assert.IsFalse(b == a);
                Assert.IsFalse(b.Equals(a));
                Assert.IsFalse(((object)b).Equals(a));
                Assert.IsFalse(b.Equals((object)a));

                // Compare LR unequal type and non-equal instance
                Assert.AreNotEqual(b, c);
                Assert.IsFalse(b == c);
                Assert.IsFalse(b.Equals(c));
                Assert.IsFalse(((object)b).Equals(c));
                Assert.IsFalse(b.Equals((object)c));

                // Compare RL unequal type and non-equal instance
                Assert.AreNotEqual(c, b);
                Assert.IsFalse(c == b);
                Assert.IsFalse(c.Equals(b));
                Assert.IsFalse(((object)c).Equals(b));
                Assert.IsFalse(c.Equals((object)b));

                var comparer = EqualityComparer <NodeHandle> .Default;

                Assert.IsTrue(comparer.Equals(a, a));

                Assert.IsFalse(comparer.Equals(b, a));
                Assert.IsFalse(comparer.Equals(a, b));

                Assert.IsFalse(comparer.Equals(a, c));
                Assert.IsFalse(comparer.Equals(c, a));

                Assert.IsFalse(comparer.Equals(c, b));
                Assert.IsFalse(comparer.Equals(b, c));

                set.Destroy(a, b, c);
            }
        }