From 67f56f0795ac0214f9828c42f8face229e204c1d Mon Sep 17 00:00:00 2001 From: David Miller Date: Sat, 21 Feb 2009 06:55:20 +0000 Subject: ClojureCLR: added ClojureCLR project to repo. --- .../LibTests/PersistentVectorTests.cs | 330 +++++++++++++++++++++ 1 file changed, 330 insertions(+) create mode 100644 ClojureCLR/Clojure/Clojure.Tests/LibTests/PersistentVectorTests.cs (limited to 'ClojureCLR/Clojure/Clojure.Tests/LibTests/PersistentVectorTests.cs') diff --git a/ClojureCLR/Clojure/Clojure.Tests/LibTests/PersistentVectorTests.cs b/ClojureCLR/Clojure/Clojure.Tests/LibTests/PersistentVectorTests.cs new file mode 100644 index 00000000..bde46e9f --- /dev/null +++ b/ClojureCLR/Clojure/Clojure.Tests/LibTests/PersistentVectorTests.cs @@ -0,0 +1,330 @@ +/** + * 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 RMExpect = Rhino.Mocks.Expect; + +namespace Clojure.Tests.LibTests +{ + [TestFixture] + public class PersistentVectorTests : AssertionHelper + { + + #region C-tor tests + + [Test] + public void CreateOnISeqReturnsCorrectCount() + { + Range r = new Range(2,5); + PersistentVector v = PersistentVector.create(r); + + Expect(v.count(),EqualTo(r.count())); + } + + [Test] + public void CreateOnISeqHasItems() + { + Range r = new Range(2, 5); + PersistentVector v = PersistentVector.create(r); + + Expect(v.nth(0), EqualTo(2)); + Expect(v.nth(1), EqualTo(3)); + Expect(v.nth(2), EqualTo(4)); + } + + [Test] + public void CreateOnISeqWithManyItemsWorks() + { + // Want to bust out of the first tail, so need to insert more than 32 elements. + Range r = new Range(2, 1000); + PersistentVector v = PersistentVector.create(r); + + Expect(v.count(), EqualTo(r.count())); + for (int i = 0; i < v.count(); ++i) + Expect(v.nth(i), EqualTo(i + 2)); + } + + [Test] + public void CreateOnISeqWithManyManyItemsWorks() + { + // Want to bust out of the first tail, so need to insert more than 32 elements. + // Let's get out of the second level, too. + + Range r = new Range(2, 100000); + PersistentVector v = PersistentVector.create(r); + + Expect(v.count(), EqualTo(r.count())); + for (int i = 0; i < v.count(); ++i) + Expect(v.nth(i), EqualTo(i + 2)); + } + + [Test] + public void CreateOnMultipleItemsWorks() + { + PersistentVector v = PersistentVector.create(2,3,4); + + Expect(v.count(),EqualTo(3)); + Expect(v.nth(0), EqualTo(2)); + Expect(v.nth(1), EqualTo(3)); + Expect(v.nth(2), EqualTo(4)); + } + + #endregion + + #region IPersistentVector tests + + + // nth - tested in c-tor tests + + + [Test] + public void CountYieldsLength() + { + PersistentVector v = PersistentVector.create(1, 2, 3); + + Expect(v.length(), EqualTo(3)); + } + + [Test] + [ExpectedException(typeof(IndexOutOfRangeException))] + public void NthOutOfRangeLowFails() + { + PersistentVector v = PersistentVector.create(1, 2, 3); + object obj = v.nth(-4); + } + + [Test] + [ExpectedException(typeof(IndexOutOfRangeException))] + public void NthOutOfRangeHighFails() + { + PersistentVector v = PersistentVector.create(1, 2, 3); + object obj = v.nth(4); + } + + [Test] + public void AssocNReplacesInRangeForSmall() + { + Range r = new Range(2, 5); + PersistentVector v1 = PersistentVector.create(r); + IPersistentVector v2 = v1.assocN(1,10); + + Expect(v1.nth(0), EqualTo(2)); + Expect(v1.nth(1), EqualTo(3)); + Expect(v1.nth(2), EqualTo(4)); + Expect(v1.count(), EqualTo(3)); + Expect(v2.nth(0), EqualTo(2)); + Expect(v2.nth(1), EqualTo(10)); + Expect(v2.nth(2), EqualTo(4)); + Expect(v2.count(), EqualTo(3)); + } + + [Test] + public void AssocNAddsAtEndForSmall() + { + Range r = new Range(2, 5); + PersistentVector v1 = PersistentVector.create(r); + IPersistentVector v2 = v1.assocN(3, 10); + + Expect(v1.nth(0), EqualTo(2)); + Expect(v1.nth(1), EqualTo(3)); + Expect(v1.nth(2), EqualTo(4)); + Expect(v1.count(), EqualTo(3)); + Expect(v2.nth(0), EqualTo(2)); + Expect(v2.nth(1), EqualTo(3)); + Expect(v2.nth(2), EqualTo(4)); + Expect(v2.nth(3), EqualTo(10)); + Expect(v2.count(), EqualTo(4)); + } + + [Test] + [ExpectedException(typeof(IndexOutOfRangeException))] + public void AssocNOutOfRangeLowThrowsException() + { + Range r = new Range(2, 5); + PersistentVector v1 = PersistentVector.create(r); + IPersistentVector v2 = v1.assocN(-4, 10); + } + + [Test] + [ExpectedException(typeof(IndexOutOfRangeException))] + public void AssocNOutOfRangeHighThrowsException() + { + Range r = new Range(2, 5); + PersistentVector v1 = PersistentVector.create(r); + IPersistentVector v2 = v1.assocN(4, 10); + } + + [Test] + public void AssocNAddsAtEndForEmpty() + { + PersistentVector v1 = PersistentVector.create(); + IPersistentVector v2 = v1.assocN(0, "abc"); + + Expect(v1.count(), EqualTo(0)); + Expect(v2.count(), EqualTo(1)); + Expect(v2.nth(0), EqualTo("abc")); + } + + [Test] + public void AssocNChangesForBig() + { + Range r = new Range(2, 100000); + PersistentVector v1 = PersistentVector.create(r); + IPersistentVector v2 = v1; + + for (int i = 0; i < 110000; i++) + v2 = v2.assocN(i, i + 20); + + for ( int i=0; i(); + mocks.ReplayAll(); + + PersistentVector v1 = PersistentVector.create(1, 2, 3); + IPersistentCollection e1 = v1.empty(); + + PersistentVector v2 = (PersistentVector) v1.withMeta(meta); + IPersistentCollection e2 = v2.empty(); + + Expect(((IObj)e1).meta(), Null); + Expect(((IObj)e2).meta(), SameAs(meta)); + + mocks.VerifyAll(); + } + + + #endregion + + #region IPersistentStack tests + + [Test] + [ExpectedException(typeof(InvalidOperationException))] + public void PopOnEmptyThrowsException() + { + PersistentVector v = PersistentVector.create(); + IPersistentStack s = v.pop(); + } + + [Test] + public void PopOnSizeOneReturnsEmpty() + { + PersistentVector v = PersistentVector.create(1); + IPersistentStack s = v.pop(); + + Expect(s.count(), EqualTo(0)); + } + + [Test] + public void PopOnSmallReturnsOneLess() + { + Range r = new Range(2, 20); + PersistentVector v = PersistentVector.create(r); + IPersistentStack s = v.pop(); + + Expect(v.count(),EqualTo(r.count())); + Expect(s.count(),EqualTo(v.count()-1)); + } + + [Test] + public void PopOnBigWorks() + { + Range r = new Range(0, 100000); + PersistentVector v = PersistentVector.create(r); + IPersistentStack s = v; + for (int i = 16; i < 100000; i++) + s = s.pop(); + + Expect(v.count(), EqualTo(r.count())); + Expect(s.count(), EqualTo(16)); + } + + + #endregion + + #region IFn tests + + #endregion + } + + [TestFixture] + public class PersistentVector_IObj_Tests : IObjTests + { + MockRepository _mocks; + + [SetUp] + public void Setup() + { + _mocks = new MockRepository(); + IPersistentMap meta = _mocks.StrictMock(); + _mocks.ReplayAll(); + + PersistentVector v = PersistentVector.create(2, 3, 4); + + _objWithNullMeta = (IObj)v; + _obj = _objWithNullMeta.withMeta(meta); + _expectedType = typeof(PersistentVector); + } + + [TearDown] + public void Teardown() + { + _mocks.VerifyAll(); + } + + } + +} -- cgit v1.2.3-18-g5258