C# CPV类代码示例

        public void AssocWithNumericKeyInRangeChangesValue()
        {
            //This just checks that APersistentVector.assoc calls CPV.assocN
            CPV v = new CPV(new object[] { 4, 5, 6 });
            Associative a = v.assoc(1, 10);

            Expect(a.valAt(0), EqualTo(4));
            Expect(a.valAt(1), EqualTo(10));
            Expect(a.valAt(2), EqualTo(6));
            Expect(a.count(), EqualTo(3));
        }

        public void EqualsOnNonPersistentVectorIsFalse()
        {
            CPV v1 = new CPV(new object[] { 1, 2, 3 });

            Expect(v1.equiv(7), False);
        }

        public void ContainsKeyOnIndexInRangeIsTrue()
        {
            CPV v = new CPV(new object[] { 4, 5, 6 });

            Expect(v.containsKey(1.2));
        }

        public void ValAtOnNonNumericReturnsDefault()
        {
            CPV v = new CPV(new object[] { 4, 5, 6 });

            object val1 = v.valAt("a");
            object val2 = v.valAt("a", "abc");

            Expect(val1, Null);
            Expect(val2, EqualTo("abc"));
        }

        public void ValAtOnIndexInRangeReturnsEntry()
        {
            CPV v = new CPV(new object[] { 4, 5, 6 });

            object val1 = v.valAt(1);
            object val2 = v.valAt(1, "abc");

            Expect(val1, EqualTo(5));
            Expect(val2, EqualTo(5));
        }

        public void SeqWithMetaHasMeta()
        {
            MockRepository mocks = new MockRepository();
            IPersistentMap meta = mocks.StrictMock<IPersistentMap>();
            mocks.ReplayAll();

            CPV v = new CPV(new object[] { 4, 5, 6 });
            IObj s = (IObj)v.seq();
            IObj obj = s.withMeta(meta);

            Expect(obj.meta(), SameAs(meta));
            mocks.VerifyAll();
        }

        public void SeqOnPositiveCountYieldsValidSequence()
        {
            CPV v = new CPV(new object[] { 1, 2, 3 });
            ISeq s = v.seq();

            Expect(s.first(), EqualTo(1));
            Expect(s.rest().first(), EqualTo(2));
            Expect(s.rest().rest().first(), EqualTo(3));
            Expect(s.rest().rest().rest(), Null);
        }

        public void HashCodeRepeats()
        {
            CPV v = new CPV(new object[] { 1, 2, 3 });

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

        public void InvokeCallsNth()
        {
            CPV v = new CPV(new object[] { 5, 6, 7 });

            Expect(v.invoke(0),EqualTo(5));
            Expect(v.invoke(1),EqualTo(6));
            Expect(v.invoke(2),EqualTo(7));
            Expect(v.invoke("1"), EqualTo(6));
            Expect(v.invoke(1.0), EqualTo(6));
            Expect(v.invoke(1.2), EqualTo(6));
            Expect(v.invoke(1.8), EqualTo(6)); // Rounds or not-- should it?
            Expect(v.invoke(1.4M), EqualTo(6));
        }

        public void Explicit_IPersistentCollection_cons_works()
        {
            CPV v = new CPV(new object[] { 1, 2 });
            IPersistentCollection c = v as IPersistentCollection;

            Expect(c, Not.Null);

            IPersistentCollection c2 = c.cons(3);
            Expect(c2.count(), EqualTo(3));

            ISeq s2 = c2.seq();

            Expect(s2.first(), EqualTo(1));
            Expect(s2.rest().first(), EqualTo(2));
            Expect(s2.rest().rest().first(), EqualTo(3));
            Expect(s2.rest().rest().rest(), Null);
        }

        public void HashCodeDependsOnItems()
        {
            CPV v1 = new CPV(new object[] { 1, 2, 3 });
            CPV v2 = new CPV(new object[] { 1, 2, 4 });

            Expect(v1.GetHashCode(), Not.EqualTo(v2.GetHashCode()));
        }

        public void EqualsOnSimilarISeqWorks()
        {
            CPV v1 = new CPV(new object[] { 'a', 'b', 'c' });
            StringSeq s1 = StringSeq.create("abc");

            Expect(v1.equiv(s1));
        }

        public void EqualsOnPersistentVectorWithSameItemsIsTrue()
        {
            CPV v1 = new CPV(new object[] { 1, 2, 3 });
            CPV v2 = new CPV(new object[] { 1, 2, 3 });
            CPV v3 = new CPV(new object[] { 1 });
            CPV v4 = new CPV(new object[] { 1 });
            CPV v5 = new CPV(new object[] { });
            CPV v6 = new CPV(new object[] { });

            Expect(v1.equiv(v2));
            Expect(v3.equiv(v4));
            Expect(v5.equiv(v6));
        }

        public void EqualsOnPersistentVectorWithDifferentItemsIsFalse()
        {
            CPV v1 = new CPV(new object[] { 1, 2, 3 });
            CPV v2 = new CPV(new object[] { 1, 2, 4 });
            CPV v3 = new CPV(new object[] { 1, 2 });
            CPV v4 = new CPV(new object[] { 1, 2, 3, 4 });

            Expect(v1.equiv(v2), False);
            Expect(v1.equiv(v3), False);
            Expect(v1.equiv(v4), False);
        }

        public void SeqIndexedWorks()
        {
            CPV v = new CPV(new object[] { 4, 5, 6 });
            ISeq s0 = v.seq();
            IndexedSeq i0 = s0 as IndexedSeq;

            ISeq s1 = s0.rest();
            IndexedSeq i1 = s1 as IndexedSeq;

            Expect(i0.index(), EqualTo(0));
            Expect(i1.index(), EqualTo(1));
        }