aboutsummaryrefslogtreecommitdiff
path: root/ClojureCLR/Clojure/Clojure.Tests/LibTests/MapEntryTests.cs
diff options
context:
space:
mode:
authorDavid Miller <dmiller2718@gmail.com>2009-02-21 06:55:20 +0000
committerDavid Miller <dmiller2718@gmail.com>2009-02-21 06:55:20 +0000
commit67f56f0795ac0214f9828c42f8face229e204c1d (patch)
treef01b57d581c3a48d87fb4d72b023bc8d609a24cd /ClojureCLR/Clojure/Clojure.Tests/LibTests/MapEntryTests.cs
parent64d79207eed0fe057a19fe4d3d0f6b714a63c69a (diff)
ClojureCLR: added ClojureCLR project to repo.
Diffstat (limited to 'ClojureCLR/Clojure/Clojure.Tests/LibTests/MapEntryTests.cs')
-rw-r--r--ClojureCLR/Clojure/Clojure.Tests/LibTests/MapEntryTests.cs369
1 files changed, 369 insertions, 0 deletions
diff --git a/ClojureCLR/Clojure/Clojure.Tests/LibTests/MapEntryTests.cs b/ClojureCLR/Clojure/Clojure.Tests/LibTests/MapEntryTests.cs
new file mode 100644
index 00000000..2a5253fb
--- /dev/null
+++ b/ClojureCLR/Clojure/Clojure.Tests/LibTests/MapEntryTests.cs
@@ -0,0 +1,369 @@
+/**
+ * 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 MapEntryTests : AssertionHelper
+ {
+ #region C-tor tests
+
+ [Test]
+ public void CtorCreatesEntryWithProperKeyVal()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+
+ Expect(me.key(), EqualTo(1));
+ Expect(me.val(), EqualTo("abc"));
+ }
+
+ #endregion
+
+ #region Object override tests
+
+ [Test]
+ public void HashCodeSameAsPersistentVector()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+ PersistentVector v = PersistentVector.create(1, "abc");
+
+ Expect(me.GetHashCode(), EqualTo(v.GetHashCode()));
+ }
+
+ [Test]
+ public void HashCodeFalseOnDifferentValues()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+ PersistentVector v = PersistentVector.create(1, "abcd");
+
+ Expect(me.GetHashCode(), Not.EqualTo(v.GetHashCode()));
+ }
+
+ [Test]
+ public void EqualsWorksOnPersistentVector()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+ PersistentVector v = PersistentVector.create(1, "abc");
+
+ Expect(me.Equals(v));
+ }
+
+ [Test]
+ public void EqualsWorksFalseOnDifferentValues()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+ PersistentVector v = PersistentVector.create(1, "abcd");
+
+ Expect(me.Equals(v),False);
+ }
+
+
+ #endregion
+
+ #region IMapEntry tests
+
+ #endregion
+
+ #region IPersistentVector tests
+
+ [Test]
+ public void LengthIs2()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+
+ Expect(me.length(), EqualTo(2));
+ }
+
+ [Test]
+ public void NthInRangeWorks()
+ {
+
+ MapEntry me = new MapEntry(1, "abc");
+
+ Expect(me.nth(0), EqualTo(1));
+ Expect(me.nth(1), EqualTo("abc"));
+ }
+
+ [Test]
+ [ExpectedException(typeof(IndexOutOfRangeException))]
+ public void NthOutOfRangeLowFails()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+ object obj = me.nth(-4);
+ }
+
+ [Test]
+ [ExpectedException(typeof(IndexOutOfRangeException))]
+ public void NthOutOfRangeHighFails()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+ object obj = me.nth(4);
+ }
+
+ [Test]
+ 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"));
+ }
+
+ [Test]
+ [ExpectedException(typeof(IndexOutOfRangeException))]
+ public void AssocNOutOfRangeLowThrows()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+ IPersistentVector v1 = me.assocN(-4, 2);
+ }
+
+ [Test]
+ [ExpectedException(typeof(IndexOutOfRangeException))]
+ public void AssocNOutOfRangeHighThrows()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+ IPersistentVector v1 = me.assocN(4, 2);
+ }
+
+ [Test]
+ 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));
+ }
+
+ #endregion
+
+ #region Associative tests
+
+ [Test]
+ public void ContainsKeyOnExistingKeyWorks()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+
+ Expect(me.containsKey(0));
+ Expect(me.containsKey(1));
+ }
+
+ [Test]
+ public void ContainsKeyOutOfRangeIsFalse()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+
+ Expect(me.containsKey(-4),False);
+ Expect(me.containsKey(4), False);
+ }
+
+
+ [Test]
+ 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"));
+ }
+
+ [Test]
+ public void EntryAtOutOfRangeLowReturnsNull()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+ IMapEntry me1 = me.entryAt(-4);
+
+ Expect(me1,Null);
+ }
+
+ [Test]
+ public void EntryAtOutOfRangeHighReturnsNull()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+ IMapEntry me1 = me.entryAt(4);
+
+ Expect(me1, Null);
+ }
+
+ [Test]
+ public void ValAtOnExistingKeyReturnsValue()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+
+ Expect(me.valAt(0), EqualTo(1));
+ Expect(me.valAt(1), EqualTo("abc"));
+ }
+
+ [Test]
+ public void ValAtOnMissingKeyReturnsNull()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+
+ Expect(me.valAt(-4), Null);
+ Expect(me.valAt(4), Null);
+ }
+
+ [Test]
+ public void ValAtWithDefaultOnExistingKeyReturnsValue()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+
+ Expect(me.valAt(0,7), EqualTo(1));
+ Expect(me.valAt(1,7), EqualTo("abc"));
+ }
+
+ [Test]
+ public void ValAtWithDefaultOnMissingKeyReturnsDefault()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+
+ Expect(me.valAt(-4,7), EqualTo(7));
+ Expect(me.valAt(4, 7), EqualTo(7));
+ }
+
+ #endregion
+
+ #region Reversible tests
+
+ [Test]
+ public void RseqReturnReverseSeq()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+
+ ISeq s = me.rseq();
+
+ Expect(s.count(), EqualTo(2));
+ Expect(s.first(), EqualTo("abc"));
+ Expect(s.rest().first(), EqualTo(1));
+ Expect(s.rest().rest(), Null);
+ }
+
+ #endregion
+
+ #region IPersistentCollection tests
+
+ [Test]
+ public void CountIs2()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+ Expect(me.count(), EqualTo(2));
+ }
+
+ [Test]
+ 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.rest().first(), EqualTo("abc"));
+ Expect(s.rest().rest(), Null);
+ }
+
+ [Test]
+ public void EmptyReutrnsNull()
+ {
+ MapEntry me = new MapEntry(1, "abc");
+
+ Expect(me.empty(), Null);
+ }
+
+
+ [Test]
+ 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.rest().first(), EqualTo("abc"));
+ Expect(s.rest().rest().first(), EqualTo(2));
+ Expect(s.rest().rest().rest(), Null);
+ }
+
+ #endregion
+
+ #region IPersistentStack tests
+
+ [Test]
+ 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"));
+ }
+
+ [Test]
+ 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));
+ }
+
+
+
+
+ #endregion
+
+ }
+}
generated by cgit v1.2.3-18-g5258 (git 2.32.0) at 2025-04-30 18:53:07 +0000