diff options
Diffstat (limited to 'ClojureCLR/Clojure/Clojure.Tests/LibTests/ConsTests.cs')
| -rw-r--r-- | ClojureCLR/Clojure/Clojure.Tests/LibTests/ConsTests.cs | 428 |
1 files changed, 428 insertions, 0 deletions
diff --git a/ClojureCLR/Clojure/Clojure.Tests/LibTests/ConsTests.cs b/ClojureCLR/Clojure/Clojure.Tests/LibTests/ConsTests.cs new file mode 100644 index 00000000..b01e1786 --- /dev/null +++ b/ClojureCLR/Clojure/Clojure.Tests/LibTests/ConsTests.cs @@ -0,0 +1,428 @@ +/**
+ * 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);
+ Expect(c.empty(), Null);
+ }
+
+ [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.rest(), 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);
+ }
+ }
+}
|