Removing ClojureCLR (Moved to http://github.com/richhickey/clojure-clr)

1 files changed, 0 insertions, 429 deletions

diff --git a/ClojureCLR/Clojure/Clojure.Tests/LibTests/ConsTests.cs b/ClojureCLR/Clojure/Clojure.Tests/LibTests/ConsTests.cs
deleted file mode 100644
index 1b0de513..00000000
--- a/ClojureCLR/Clojure/Clojure.Tests/LibTests/ConsTests.cs
+++ /dev/null
@@ -1,429 +0,0 @@
-/**

- *   Copyright (c) David Miller. All rights reserved.

- *   The use and distribution terms for this software are covered by the

- *   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)

- *   which can be found in the file epl-v10.html at the root of this distribution.

- *   By using this software in any fashion, you are agreeing to be bound by

- * 	 the terms of this license.

- *   You must not remove this notice, or any other, from this software.

- **/

-

-using System;

-using System.Collections.Generic;

-using System.Linq;

-using System.Text;

-

-using NUnit.Framework;

-using Rhino.Mocks;

-

-using clojure.lang;

-using System.Collections;

-

-namespace Clojure.Tests.LibTests

-{

-    [TestFixture]

-    public class ConsTests : AssertionHelper

-    {

-        #region C-tor tests

-

-        [Test]

-        public void NoMetaCtorHasNoMeta()

-        {

-            Cons c = new Cons("abc",null);

-            Expect(c.meta(),Null);

-        }

-

-        [Test]

-        public void MetaCtorHasMeta()

-        {

-            MockRepository mocks = new MockRepository();

-            IPersistentMap meta = mocks.StrictMock<IPersistentMap>();

-            mocks.ReplayAll();

-

-            Cons c = new Cons(meta, "abc", null);

-

-            Expect(c.meta(), SameAs(meta));

-            mocks.VerifyAll();

-        }

-

-        #endregion

-

-        #region IPersistentCollection tests

-

-        [Test]

-        public void CountOfOneItem()

-        {

-            Cons c = new Cons("abc", null);

-

-            Expect(c.count(), EqualTo(1));

-        }

-

-        [Test]

-        public void CountOfTwoItems()

-        {

-            Cons c1 = new Cons("abc", null);

-            Cons c2 = new Cons("def", c1);

-

-            Expect(c2.count(), EqualTo(2));

-        }

-

-        [Test]

-        public void SeqReturnsSelf()

-        {

-            Cons c1 = new Cons("abc", null);

-

-            Expect(c1.seq(), SameAs(c1));

-        }

-

-        [Test]

-        public void EmptyIsNull()

-        {

-            // Test of ASeq

-            Cons c = new Cons("abc", null);

-            IPersistentCollection empty = c.empty();

-            Expect(empty, SameAs(PersistentList.EMPTY));

-        }

-

-        [Test]

-        public void IPC_Cons_works()

-        {

-            Cons c1 = new Cons("abc", null);

-            IPersistentCollection ipc1 = c1 as IPersistentCollection;

-

-            IPersistentCollection ipc2 = ipc1.cons("def");

-            ISeq s = ipc2.seq();

-

-            Expect(s.first(), EqualTo("def"));

-            Expect(s.next(), SameAs(c1));

-        }

-

-        #endregion

-

-        #region ASeq tests

-        

-        // Some aspects of ASeq have been tested above.  

-        // Here are the remaining bits

-

-        private Cons CreateComplicatedCons()

-        {

-            Cons c1 = new Cons(1, null);

-            Cons c2 = new Cons(2, c1);

-            Cons c3 = new Cons("abc", null);

-            Cons c4 = new Cons(c3, c2);

-            Cons c5 = new Cons("def", c4);

-

-            return c5;

-        }

-

-        [Test]

-        public void EqualsDoesValueComparison()

-        {

-            Cons a = CreateComplicatedCons();

-            Cons b = CreateComplicatedCons();

-

-            Expect(a.Equals(b));

-            Expect(a, EqualTo(b));

-        }

-

-        [Test]

-        public void GetHashCodeComputesOnValue()

-        {

-            Cons a = CreateComplicatedCons();

-            Cons b = CreateComplicatedCons();

-

-            Expect(a.GetHashCode(), EqualTo(b.GetHashCode()));

-        }

-

-

-        #endregion

-

-        #region ASeq.ICollection tests

-

-        [Test]

-        [ExpectedException(typeof(ArgumentException))]

-        public void ASeqICollCopyToFailsOnNullArray()

-        {

-            ICollection ic = new Cons(1, null);

-            ic.CopyTo(null, 0);

-        }

-

-        [Test]

-        [ExpectedException(typeof(ArgumentException))]

-        public void ASeqICollCopyToFailsOnInsufficientSpace()

-        {

-            ICollection ic = new Cons(1, new Cons(2, new Cons(3,null)));

-            Array arr = new object[2];

-            ic.CopyTo(arr, 0);

-        }

-

-        [Test]

-        [ExpectedException(typeof(ArgumentException))]

-        public void ASeqICollCopyToFailsOnInsufficientSpace2()

-        {

-            ICollection ic = new Cons(1, new Cons(2, new Cons(3, null)));

-            Array arr = new object[10];

-            ic.CopyTo(arr, 8);

-        }

-

-        [Test]

-        [ExpectedException(typeof(ArgumentException))]

-        public void ASeqICollCopyToFailsOnMultidimArray()

-        {

-            ICollection ic = new Cons(1, new Cons(2, new Cons(3, null)));

-            Array arr = Array.CreateInstance(typeof(int), 4, 4);

-            ic.CopyTo(arr, 0);

-        }

-

-        [Test]

-        [ExpectedException(typeof(ArgumentOutOfRangeException))]

-        public void ASeqICollCopyToFailsOnNegativeIndex()

-        {

-            ICollection ic = new Cons(1, new Cons(2, new Cons(3, null)));

-            Array arr = new object[10];

-            ic.CopyTo(arr, -1);

-        }

-

-        [Test]

-        public void ASeqICollCopyToCopiesToIndex0()

-        {

-            ICollection ic = new Cons(1, new Cons(2, new Cons(3, null)));

-            int[] arr = new int[4];

-            ic.CopyTo(arr, 0);

-

-            Expect(arr[0], EqualTo(1));

-            Expect(arr[1], EqualTo(2));

-            Expect(arr[2], EqualTo(3));

-            Expect(arr[3], EqualTo(0));

-        }

-

-        [Test]

-        public void ASeqICollCopyToCopiesToIndexPositive()

-        {

-            ICollection ic = new Cons(1, new Cons(2, new Cons(3, null)));

-            int[] arr = new int[4];

-            ic.CopyTo(arr, 1);

-

-            Expect(arr[0], EqualTo(0));

-            Expect(arr[1], EqualTo(1));

-            Expect(arr[2], EqualTo(2));

-            Expect(arr[3], EqualTo(3));

-        }

-

-        [Test]

-        public void ASeqICollCountWorks()

-        {

-            ICollection ic = new Cons(1, new Cons(2, new Cons(3, null)));

-

-            Expect(ic.Count, EqualTo(3));

-        }

-

-        [Test]

-        public void ASeqICollIsSynchronized()

-        {

-            ICollection ic = new Cons(1, new Cons(2, new Cons(3, null)));

-            Expect(ic.IsSynchronized);

-        }

-

-        [Test]

-        [ExpectedException(typeof(NotImplementedException))]

-        public void ASeqICollHasDoesntImplementSyncRoot()

-        {

-            ICollection ic = new Cons(1, new Cons(2, new Cons(3, null)));

-            Object o = ic.SyncRoot;

-        }

-

-        [Test]

-        public void ASeqIEnumWorks()

-        {

-            ICollection ic = new Cons(1, new Cons(2, new Cons(3, null)));

-            IEnumerator e = ic.GetEnumerator();

-

-            Expect(e.MoveNext());

-            Expect(e.Current, EqualTo(1));

-            Expect(e.MoveNext());

-            Expect(e.Current, EqualTo(2));

-            Expect(e.MoveNext());

-            Expect(e.Current, EqualTo(3));

-            Expect(e.MoveNext(),False); 

-        }

-

-

-        #endregion

-

-        #region SeqIterator tests

-

-        [Test]

-        public void SeqIteratorOnEmptySeqGoesNowhere()

-        {

-            SeqEnumerator s = new SeqEnumerator(null);

-

-            Expect(s.MoveNext(), False);

-        }

-

-        [Test]

-        [ExpectedException(typeof(InvalidOperationException))]

-        public void SeqIteratorOnEmptyHasNoCurrent()

-        {

-            SeqEnumerator s = new SeqEnumerator(null);

-            object o = s.Current;

-        }

-

-        [Test]

-        public void SeqIteratorIterates()

-        {

-            Cons c = new Cons(1, new Cons(2, null));

-            SeqEnumerator s = new SeqEnumerator(c);

-

-            Expect(s.MoveNext());

-            Expect(s.Current, EqualTo(1));

-            Expect(s.MoveNext());

-            Expect(s.Current, EqualTo(2));

-            Expect(s.Current, EqualTo(2));

-            Expect(s.MoveNext(), False);

-        }

-

-        [Test]

-        [ExpectedException(typeof(InvalidOperationException))]

-        public void SeqIteratorMovedToEmptyHasNoCurrent()

-        {

-            Cons c = new Cons(1, new Cons(2, null));

-            SeqEnumerator s = new SeqEnumerator(c);

-            

-            s.MoveNext();

-            s.MoveNext();

-            s.MoveNext();

-            object o = s.Current;

-        }

-

-

-        [ExpectedException(typeof(InvalidOperationException))]

-        public void SeqIteratorResetAtBeginningWorks()

-        {

-            Cons c = new Cons(1, new Cons(2, null));

-            SeqEnumerator s = new SeqEnumerator(c);

-

-            s.Reset();

-

-            Expect(s.MoveNext());

-            Expect(s.Current, EqualTo(1));

-            Expect(s.MoveNext());

-            Expect(s.Current, EqualTo(2));

-            Expect(s.Current, EqualTo(2));

-            Expect(s.MoveNext(), False);

-        }

-

-        [Test]

-        public void SeqIteratorResetAtFirstWorks()

-        {

-            Cons c = new Cons(1, new Cons(2, null));

-            SeqEnumerator s = new SeqEnumerator(c);

-

-            s.MoveNext();

-            s.Reset();

-

-            Expect(s.MoveNext());

-            Expect(s.Current, EqualTo(1));

-            Expect(s.MoveNext());

-            Expect(s.Current, EqualTo(2));

-            Expect(s.Current, EqualTo(2));

-            Expect(s.MoveNext(), False);

-        }

-

-        [Test]

-        public void SeqIteratorResetInMiddleWorks()

-        {

-            Cons c = new Cons(1, new Cons(2, null));

-            SeqEnumerator s = new SeqEnumerator(c);

-

-            s.MoveNext();

-            s.MoveNext();

-            s.Reset();

-

-            Expect(s.MoveNext());

-            Expect(s.Current, EqualTo(1));

-            Expect(s.MoveNext());

-            Expect(s.Current, EqualTo(2));

-            Expect(s.Current, EqualTo(2));

-            Expect(s.MoveNext(), False);

-        }

-

-        [Test]

-        public void SeqIteratorResetAtEndWorks()

-        {

-            Cons c = new Cons(1, new Cons(2, null));

-            SeqEnumerator s = new SeqEnumerator(c);

-

-            s.MoveNext();

-            s.MoveNext();

-            s.MoveNext();

-            s.Reset();

-

-            Expect(s.MoveNext());

-            Expect(s.Current, EqualTo(1));

-            Expect(s.MoveNext());

-            Expect(s.Current, EqualTo(2));

-            Expect(s.Current, EqualTo(2));

-            Expect(s.MoveNext(), False);

-        }

-

-        #endregion

-    }

-

-    [TestFixture]

-    public class Cons_ISeq_Tests : ISeqTestHelper

-    {

-

-        [Test]

-        public void Cons_ISeq_has_correct_values()

-        {

-            Cons c1 = new Cons("def", null);

-            Cons c2 = new Cons("abc", c1);

-

-            VerifyISeqContents(c2, new object[] { "abc", "def" });

-        }

-

-        [Test]

-        public void Cons_ISeq_with_meta_has_correct_values()

-        {

-            MockRepository mocks = new MockRepository();

-            IPersistentMap meta = mocks.StrictMock<IPersistentMap>();

-            mocks.ReplayAll();

-

-            Cons c1 = new Cons("def", null);

-            Cons c2 = new Cons(meta,"abc", c1);

-

-            VerifyISeqContents(c2, new object[] { "abc", "def" });

-            mocks.VerifyAll();

-        }

-

-        [Test]

-        public void Cons_ISeq_conses()

-        {

-

-            Cons c1 = new Cons("def", null);

-            Cons c2 = new Cons("abc", c1);

-

-            VerifyISeqCons(c2, "ghi", new object[] { "abc", "def" });

-        }

-

-

-

-    }

-

-

-    [TestFixture]

-    public class Cons_IMeta_Tests : IObjTests

-    {

-        [SetUp]

-        public void Setup()

-        {

-            IPersistentMap meta = PersistentHashMap.create("a", 1, "b", 2);

-

-            Cons c1 = new Cons("abc", null);

-            Cons c2 = new Cons(meta,"def", c1);

-            _obj = c2;

-            _objWithNullMeta = c1;

-            _expectedType = typeof(Cons);

-        }

-    }

-}