public void HashCodeFalseOnDifferentValues()
        {
            MapEntry me = new MapEntry(1, "abc");
            PersistentVector v = PersistentVector.create(1, "abcd");

            Expect(me.GetHashCode(), Not.EqualTo(v.GetHashCode()));
        }

        public void EqualsWorksFalseOnDifferentValues()
        {
            MapEntry me = new MapEntry(1, "abc");
            PersistentVector v = PersistentVector.create(1, "abcd");

            Expect(me.Equals(v),False);
        }

        public void HashCodeSameAsPersistentVector()
        {
            MapEntry me = new MapEntry(1, "abc");
            PersistentVector v = PersistentVector.create(1, "abc");

            Expect(me.GetHashCode(), EqualTo(v.GetHashCode()));
        }

        public void CtorCreatesEntryWithProperKeyVal()
        {
            MapEntry me = new MapEntry(1, "abc");

            Expect(me.key(), EqualTo(1));
            Expect(me.val(), EqualTo("abc"));
        }

        public void EqualsWorksOnPersistentVector()
        {
            MapEntry me = new MapEntry(1, "abc");
            PersistentVector v = PersistentVector.create(1, "abc");

            Expect(me.Equals(v));
        }

        public void ConsWorks()
        {
            MapEntry me = new MapEntry(1, "abc");
            IPersistentVector v1 = me.cons(2);

            Expect(me.count(), EqualTo(2));
            Expect(me.key(), EqualTo(1));
            Expect(me.val(), EqualTo("abc"));

            Expect(v1.count(), EqualTo(3));
            Expect(v1.nth(0), EqualTo(1));
            Expect(v1.nth(1), EqualTo("abc"));
            Expect(v1.nth(2), EqualTo(2));
        }

        public void AssocNInRangeModifies()
        {
            MapEntry me = new MapEntry(1, "abc");
            IPersistentVector v1 = me.assocN(0, 2);
            IPersistentVector v2 = me.assocN(1, "def");
            IPersistentVector v3 = me.assocN(2, "ghi");

            Expect(me.count(), EqualTo(2));
            Expect(me.key(), EqualTo(1));
            Expect(me.val(), EqualTo("abc"));

            Expect(v1.count(), EqualTo(2));
            Expect(v1.nth(0), EqualTo(2));
            Expect(v1.nth(1), EqualTo("abc"));

            Expect(v2.count(), EqualTo(2));
            Expect(v2.nth(0), EqualTo(1));
            Expect(v2.nth(1), EqualTo("def"));

            Expect(v3.count(), EqualTo(3));
            Expect(v3.nth(0), EqualTo(1));
            Expect(v3.nth(1), EqualTo("abc"));
            Expect(v3.nth(2), EqualTo("ghi"));
        }

        public void EmptyReutrnsNull()
        {
            MapEntry me = new MapEntry(1, "abc");

            Expect(me.empty(), Null);
        }

        public void SeqReturnsASeq()
        {
            MapEntry me = new MapEntry(1, "abc");
            ISeq s = me.seq();

            Expect(s.count(), EqualTo(2));
            Expect(s.first(), EqualTo(1));
            Expect(s.next().first(), EqualTo("abc"));
            Expect(s.next().next(), Null);
        }

 public void CountIs2()
 {
     MapEntry me = new MapEntry(1, "abc");
     Expect(me.count(), EqualTo(2));
 }

        public void PeekReturnsVal()
        {
            MapEntry me = new MapEntry(1, "abc");

            Expect(me.peek(), EqualTo("abc"));
            Expect(me.count(), EqualTo(2));
            Expect(me.key(), EqualTo(1));
            Expect(me.val(), EqualTo("abc"));
        }

        public void EntryAtOnExistingKeyWorks()
        {
            MapEntry me = new MapEntry(1, "abc");
            IMapEntry me1 = me.entryAt(0);
            IMapEntry me2 = me.entryAt(1);

            Expect(me1.key(), EqualTo(0));
            Expect(me1.val(), EqualTo(1));
            Expect(me2.key(), EqualTo(1));
            Expect(me2.val(), EqualTo("abc"));
        }

        public void ContainsKeyOutOfRangeIsFalse()
        {
            MapEntry me = new MapEntry(1, "abc");

            Expect(me.containsKey(-4),False);
            Expect(me.containsKey(4), False);
        }

        public void ContainsKeyOnExistingKeyWorks()
        {
            MapEntry me = new MapEntry(1, "abc");

            Expect(me.containsKey(0));
            Expect(me.containsKey(1));
        }

 public void AssocNOutOfRangeHighThrows()
 {
     MapEntry me = new MapEntry(1, "abc");
     me.assocN(4, 2);
 }

 public void NthOutOfRangeHighFails()
 {
     MapEntry me = new MapEntry(1, "abc");
     me.nth(4);
 }

 public void NthOutOfRangeLowFails()
 {
     MapEntry me = new MapEntry(1, "abc");
     me.nth(-4);
 }

        public void ExplictIPersistentCollectionConsWorks()
        {
            MapEntry me = new MapEntry(1, "abc");
            IPersistentCollection c = (IPersistentCollection)me;
            ISeq s = c.cons(2).seq();

            Expect(me.count(), EqualTo(2));
            Expect(me.key(), EqualTo(1));
            Expect(me.val(), EqualTo("abc"));

            Expect(s.count(), EqualTo(3));
            Expect(s.first(), EqualTo(1));
            Expect(s.next().first(), EqualTo("abc"));
            Expect(s.next().next().first(), EqualTo(2));
            Expect(s.next().next().next(), Null);
        }

        public void EntryAtOutOfRangeHighReturnsNull()
        {
            MapEntry me = new MapEntry(1, "abc");
            IMapEntry me1 = me.entryAt(4);

            Expect(me1, Null);
        }

        public void PopLosesTheValue()
        {
            MapEntry me = new MapEntry(1, "abc");
            IPersistentVector v = (IPersistentVector)me.pop();

            Expect(v.length(), EqualTo(1));
            Expect(v.nth(0), EqualTo(1));
        }