From 67f56f0795ac0214f9828c42f8face229e204c1d Mon Sep 17 00:00:00 2001
From: David Miller <dmiller2718@gmail.com>
Date: Sat, 21 Feb 2009 06:55:20 +0000
Subject: ClojureCLR: added ClojureCLR project to repo.

---
 .../LibTests/PersistentArrayMapTests.cs            | 917 +++++++++++++++++++++
 1 file changed, 917 insertions(+)
 create mode 100644 ClojureCLR/Clojure/Clojure.Tests/LibTests/PersistentArrayMapTests.cs

(limited to 'ClojureCLR/Clojure/Clojure.Tests/LibTests/PersistentArrayMapTests.cs')

diff --git a/ClojureCLR/Clojure/Clojure.Tests/LibTests/PersistentArrayMapTests.cs b/ClojureCLR/Clojure/Clojure.Tests/LibTests/PersistentArrayMapTests.cs
new file mode 100644
index 00000000..87692146
--- /dev/null
+++ b/ClojureCLR/Clojure/Clojure.Tests/LibTests/PersistentArrayMapTests.cs
@@ -0,0 +1,917 @@
+/**
+ *   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 System.Collections;
+
+using NUnit.Framework;
+using Rhino.Mocks;
+
+using clojure.lang;
+
+using RMExpect = Rhino.Mocks.Expect;
+
+namespace Clojure.Tests.LibTests
+{
+    [TestFixture]
+    public class PersistentArrayMapTests : AssertionHelper
+    {
+        #region  C-tor tests
+
+        [Test]
+        public void CreateOnEmptyDictionaryReturnsEmptyMap()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            Expect(m.count(), EqualTo(0));
+        }
+
+        [Test]
+        public void CreateOnDictionaryReturnsMap()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            Expect(m.count(), EqualTo(2));
+            Expect(m.valAt(1), EqualTo("a"));
+            Expect(m.valAt(2), EqualTo("b"));
+            Expect(m.containsKey(3), False);
+        }
+
+        // other c-tors are not public.
+
+
+        #endregion
+        
+        #region  Associative tests
+
+        [Test]
+        public void ContainsKeyOnMissingKeyIsFalse()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            Expect(m.containsKey(3), False);
+        }
+
+
+        [Test]
+        public void ContainsKeyOnExistingKeyIsTrue()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            Expect(m.containsKey(1));
+            Expect(m.containsKey(2));
+        }
+
+        [Test]
+        public void ContainsKeyNotConfusedByValue()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            Expect(m.containsKey("a"), False);
+        }
+
+        [Test]
+        public void EntryAtReturnsNullOnMissingKey()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            Expect(m.entryAt(3), Null);
+        }
+
+        [Test]
+        public void EntryAtReturnsEntryforKey()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+            IMapEntry me = m.entryAt(1);
+
+            Expect(me.key(), EqualTo(1));
+            Expect(me.val(), EqualTo("a"));
+        }
+
+        [Test]
+        public void ValAt1ReturnsNullOnMissingKey()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            Expect(m.valAt(3), Null);
+        }
+
+        [Test]
+        public void ValAt1ReturnsValueforKey()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            Expect(m.valAt(1), EqualTo("a"));
+        }
+
+
+        [Test]
+        public void ValAt2ReturnsDefaultOnMissingKey()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            Expect(m.valAt(3,99), EqualTo(99));
+        }
+
+        [Test]
+        public void ValAt2ReturnsValueforKey()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            Expect(m.valAt(1,99), EqualTo("a"));
+        }
+        
+        #endregion
+        
+        #region  IPersistentCollection tests
+
+        [Test]
+        public void CountOnEmptyReturns0()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            Expect(m.count(), EqualTo(0));
+        }
+
+        [Test]
+        public void CountOnNonEmptyReturnsCount()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            Expect(m.count(), EqualTo(2));
+        }
+
+        [Test]
+        public void EmptyReturnsEmpty()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+            IPersistentMap m = PersistentArrayMap.create(d);
+            IPersistentCollection c = m.empty();
+
+            Expect(c.count(), EqualTo(0));
+            Expect(c.seq(), Null);
+        }
+
+
+        [Test]
+        public void SeqOnEmptyReturnNull()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            IPersistentMap m = PersistentArrayMap.create(d);
+            ISeq s = m.seq();
+
+            Expect(s, Null);
+        }
+
+        [Test]
+        public void SeqOnNonEmptyIterates()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+            IPersistentMap m = PersistentArrayMap.create(d);
+            ISeq s = m.seq();
+            IMapEntry me1 = (IMapEntry)s.first();
+            IMapEntry me2 = (IMapEntry)s.rest().first();
+            ISeq end = s.rest().rest();
+
+            Expect(s.count(), EqualTo(2));
+            Expect(me1.key(), EqualTo(1) | EqualTo(2));
+            Expect(me1.val(), EqualTo(((int)me1.key()==1 ? "a" : "b")));
+            Expect(me2.key(), EqualTo(1) | EqualTo(2));
+            Expect(me2.val(), EqualTo(((int)me2.key() == 1 ? "a" : "b")));
+            Expect(end, Null);            
+        }
+
+        #endregion
+        
+        #region  IPersistentMap tests
+
+        [Test]
+        public void AssocModifiesOnExistingKey()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m1 = PersistentArrayMap.create(d);
+            IPersistentMap m2 = m1.assoc(2, "c");
+
+            Expect(m1.count(), EqualTo(2));
+            Expect(m1.valAt(2), EqualTo("b"));
+            Expect(m2.count(), EqualTo(2));
+            Expect(m2.valAt(2), EqualTo("c"));
+        }
+
+
+        [Test]
+        public void AssocAddsOnNewKey()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m1 = PersistentArrayMap.create(d);
+            IPersistentMap m2 = m1.assoc(3, "c");
+
+            Expect(m1.count(), EqualTo(2));
+            Expect(m1.containsKey(3), False);
+            Expect(m2.count(), EqualTo(3));
+            Expect(m2.valAt(3), EqualTo("c"));
+        }
+
+
+        [Test]
+        [ExpectedException(typeof(Exception))]
+        public void AssocExFailsOnExistingKey()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m1 = PersistentArrayMap.create(d);
+            IPersistentMap m2 = m1.assocEx(2, "c");
+        }
+
+
+
+        [Test]
+        public void AssocExModifiesOnNewKey()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m1 = PersistentArrayMap.create(d);
+            IPersistentMap m2 = m1.assocEx(3, "c");
+
+            Expect(m1.count(), EqualTo(2));
+            Expect(m1.containsKey(3), False);
+            Expect(m2.count(), EqualTo(3));
+            Expect(m2.valAt(3), EqualTo("c"));
+        }
+
+        [Test]
+        public void WithoutOnExistingKeyRemovesKey()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[3] = "a";
+            d[5] = "b";
+            d[7] = "c";
+
+            IPersistentMap m1 = PersistentArrayMap.create(d);
+            IPersistentMap m2 = m1.without(5);
+
+            Expect(m1.count(), EqualTo(3));
+            Expect(m1.valAt(5), EqualTo("b"));
+            Expect(m2.count(), EqualTo(2));
+            Expect(m2.containsKey(5), False);
+        }
+
+        [Test]
+        public void WithoutOnMissingKeyIsIdentity()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[3] = "a";
+            d[5] = "b";
+            d[7] = "c";
+
+            IPersistentMap m1 = PersistentArrayMap.create(d);
+            IPersistentMap m2 = m1.without(4);
+
+            Expect(m2, SameAs(m1));
+        }
+
+        #endregion
+        
+        #region  APersistentMap tests
+
+        [Test]
+        public void EqualsOnSimilarDictionaryReturnsTrue()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            Expect(m.equiv(d));
+        }
+
+        [Test]
+        public void EqualsOnDictionaryWIthDifferntValueReturnsFalse()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            d[2] = "c";
+
+            Expect(m.Equals(d),False);
+        }
+
+
+        [Test]
+        public void EqualsOnDictionaryWithExtraValueReturnsFalse()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            d[3] = "c";
+
+            Expect(m.Equals(d), False);
+        }
+
+        [Test]
+        public void HashCodeBasedOnValue()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m1 = PersistentArrayMap.create(d);
+
+            d[3] = "c";
+            IPersistentMap m2 = PersistentArrayMap.create(d);
+
+            Expect(m1.GetHashCode(), Not.EqualTo(m2.GetHashCode()));
+        }
+
+        [Test]
+        public void AssociativeDotAssocWorks()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+            Associative a = (Associative)m;
+
+            Associative a1 = a.assoc(3, "c");
+            Associative a2 = a.assoc(2, "c");
+
+            Expect(a.count(), EqualTo(2));
+            Expect(a.valAt(1), EqualTo("a"));
+            Expect(a.valAt(2), EqualTo("b"));
+            Expect(a.containsKey(3), False);
+
+            Expect(a1.count(), EqualTo(3));
+            Expect(a1.valAt(1), EqualTo("a"));
+            Expect(a1.valAt(2), EqualTo("b"));
+            Expect(a1.valAt(3), EqualTo("c"));
+
+            Expect(a2.count(), EqualTo(2));
+            Expect(a2.valAt(1), EqualTo("a"));
+            Expect(a2.valAt(2), EqualTo("c"));
+            Expect(a2.containsKey(3), False);
+        }
+
+        [Test]
+        public void ConsOnIMapEntryAddsNew()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+            IPersistentMap c = m.cons(new MapEntry(3, "c"));
+
+            Expect(m.count(), EqualTo(2));
+            Expect(m.valAt(1), EqualTo("a"));
+            Expect(m.valAt(2), EqualTo("b"));
+
+            Expect(c.count(), EqualTo(3));
+            Expect(c.valAt(1), EqualTo("a"));
+            Expect(c.valAt(2), EqualTo("b"));
+            Expect(c.valAt(3), EqualTo("c"));
+        }
+
+        [Test]
+        public void ConsOnIMapEntryReplacesExisting()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+            IPersistentMap c = m.cons(new MapEntry(2, "c"));
+
+            Expect(m.count(), EqualTo(2));
+            Expect(m.valAt(1), EqualTo("a"));
+            Expect(m.valAt(2), EqualTo("b"));
+
+            Expect(c.count(), EqualTo(2));
+            Expect(c.valAt(1), EqualTo("a"));
+            Expect(c.valAt(2), EqualTo("c"));
+        }
+
+
+        [Test]
+        public void ConsOnDictionaryEntryAddsNew()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+            IPersistentMap c = m.cons(new DictionaryEntry(3, "c"));
+
+            Expect(m.count(), EqualTo(2));
+            Expect(m.valAt(1), EqualTo("a"));
+            Expect(m.valAt(2), EqualTo("b"));
+
+            Expect(c.count(), EqualTo(3));
+            Expect(c.valAt(1), EqualTo("a"));
+            Expect(c.valAt(2), EqualTo("b"));
+            Expect(c.valAt(3), EqualTo("c"));
+        }
+
+        [Test]
+        public void ConsOnDictionaryEntryReplacesExisting()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+            IPersistentMap c = m.cons(new DictionaryEntry(2, "c"));
+
+            Expect(m.count(), EqualTo(2));
+            Expect(m.valAt(1), EqualTo("a"));
+            Expect(m.valAt(2), EqualTo("b"));
+
+            Expect(c.count(), EqualTo(2));
+            Expect(c.valAt(1), EqualTo("a"));
+            Expect(c.valAt(2), EqualTo("c"));
+        }
+
+        [Test]
+        public void ConsOnKeyValuePairAddsNew()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+            IPersistentMap c = m.cons(new KeyValuePair<int,string>(3, "c"));
+
+            Expect(m.count(), EqualTo(2));
+            Expect(m.valAt(1), EqualTo("a"));
+            Expect(m.valAt(2), EqualTo("b"));
+
+            Expect(c.count(), EqualTo(3));
+            Expect(c.valAt(1), EqualTo("a"));
+            Expect(c.valAt(2), EqualTo("b"));
+            Expect(c.valAt(3), EqualTo("c"));
+        }
+
+        [Test]
+        public void ConsOnKeyValuePairReplacesExisting()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+            IPersistentMap c = m.cons(new KeyValuePair<int,string>(2, "c"));
+
+            Expect(m.count(), EqualTo(2));
+            Expect(m.valAt(1), EqualTo("a"));
+            Expect(m.valAt(2), EqualTo("b"));
+
+            Expect(c.count(), EqualTo(2));
+            Expect(c.valAt(1), EqualTo("a"));
+            Expect(c.valAt(2), EqualTo("c"));
+        }
+
+        [Test]
+        public void ConsOnIPVAddsNew()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            IPersistentVector v = PersistentVector.create(3, "c");
+            IPersistentMap c = m.cons(v);
+
+            Expect(m.count(), EqualTo(2));
+            Expect(m.valAt(1), EqualTo("a"));
+            Expect(m.valAt(2), EqualTo("b"));
+
+            Expect(c.count(), EqualTo(3));
+            Expect(c.valAt(1), EqualTo("a"));
+            Expect(c.valAt(2), EqualTo("b"));
+            Expect(c.valAt(3), EqualTo("c"));
+        }
+
+        [Test]
+        public void ConsOnIPVReplacesExisting()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            IPersistentVector v = PersistentVector.create(2, "c");
+            IPersistentMap c = m.cons(v);
+
+            Expect(m.count(), EqualTo(2));
+            Expect(m.valAt(1), EqualTo("a"));
+            Expect(m.valAt(2), EqualTo("b"));
+
+            Expect(c.count(), EqualTo(2));
+            Expect(c.valAt(1), EqualTo("a"));
+            Expect(c.valAt(2), EqualTo("c"));
+        }
+
+        [Test]
+        [ExpectedException(typeof(ArgumentException))]
+        public void ConsOnNon2IPVFails()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IPersistentMap m = PersistentArrayMap.create(d);
+
+            IPersistentVector v = PersistentVector.create(2, "c", 3, "d");
+            IPersistentMap c = m.cons(v);
+
+        }
+
+        [Test]
+        public void ConsOnIPersistentMapAddsOrReplacesMany()
+        {
+            Dictionary<int, string> d1 = new Dictionary<int, string>();
+            d1[1] = "a";
+            d1[2] = "b";
+
+            IPersistentMap m1 = PersistentArrayMap.create(d1);
+
+
+            Dictionary<int, string> d2 = new Dictionary<int, string>();
+            d2[2] = "c";
+            d2[3] = "d";
+
+            IPersistentMap m2 = PersistentArrayMap.create(d2);
+            IPersistentMap m3 = m1.cons(m2);
+
+
+            Expect(m1.count(), EqualTo(2));
+            Expect(m1.valAt(1), EqualTo("a"));
+            Expect(m1.valAt(2), EqualTo("b"));
+
+            Expect(m2.count(), EqualTo(2));
+            Expect(m2.valAt(2), EqualTo("c"));
+            Expect(m2.valAt(3), EqualTo("d"));
+
+            Expect(m3.count(), EqualTo(3));
+            Expect(m3.valAt(1), EqualTo("a"));
+            Expect(m3.valAt(2), EqualTo("c"));
+            Expect(m3.valAt(3), EqualTo("d"));
+        }
+
+        [Test]
+        public void InvokeOn1ArgDoesValAt1()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IFn f = (IFn)PersistentArrayMap.create(d);
+
+            Expect(f.invoke(1), EqualTo("a"));
+            Expect(f.invoke(7),Null);
+
+        }
+        [Test]
+        public void InvokeOn2ArgsDoesValAt2()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IFn f = (IFn)PersistentArrayMap.create(d);
+
+            Expect(f.invoke(1,99), EqualTo("a"));
+            Expect(f.invoke(7,99), EqualTo(99));
+        }
+
+        [Test]
+        [ExpectedException(typeof(NotImplementedException))]
+        public void IDictionary_Add_fails()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IDictionary id = (IDictionary)PersistentArrayMap.create(d);
+            id.Add(1, "c");
+        }
+
+        [Test]
+        [ExpectedException(typeof(NotImplementedException))]
+        public void IDictionary_Clear_fails()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IDictionary id = (IDictionary)PersistentArrayMap.create(d);
+            id.Clear();
+        }
+
+        [Test]
+        [ExpectedException(typeof(NotImplementedException))]
+        public void IDictionary_Remove_fails()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IDictionary id = (IDictionary)PersistentArrayMap.create(d);
+            id.Remove(1);
+        }
+
+        [Test]
+        public void IDictionary_Contains_finds_existing_key()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IDictionary id = (IDictionary)PersistentArrayMap.create(d);
+            Expect(id.Contains(1));
+        }
+
+
+
+        [Test]
+        public void IDictionary_Contains_does_not_find_existing_key()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IDictionary id = (IDictionary)PersistentArrayMap.create(d);
+            
+            Expect(id.Contains(3),False);
+        }
+
+        [Test]
+        public void IDictionary_IsFixedSize_is_true()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IDictionary id = (IDictionary)PersistentArrayMap.create(d);
+
+            Expect(id.IsFixedSize);
+        }
+
+        [Test]
+        public void IDictionary_IsReadOnly_is_true()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IDictionary id = (IDictionary)PersistentArrayMap.create(d);
+
+            Expect(id.IsReadOnly);
+        }
+
+        [Test]
+        public void IDictionary_index_acts_like_valAt()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IDictionary id = (IDictionary)PersistentArrayMap.create(d);
+            Expect(id[2], EqualTo("b"));
+            Expect(id[3], Null);
+        }
+
+        [Test]
+        public void IDictionary_Keys_creates_key_collection()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IDictionary id = (IDictionary)PersistentArrayMap.create(d);
+            ICollection keys = id.Keys;
+
+            Expect(keys.Count, EqualTo(2));
+            int[] akeys = new int[2];
+            keys.CopyTo(akeys, 0);
+            Array.Sort(akeys);
+            Expect(akeys[0], EqualTo(1));
+            Expect(akeys[1], EqualTo(2));           
+        }
+
+        [Test]
+        public void IDictionary_Values_creates_value_collection()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IDictionary id = (IDictionary)PersistentArrayMap.create(d);
+            ICollection vals = id.Values;
+
+            Expect(vals.Count, EqualTo(2));
+            string[] avals = new string[2];
+            vals.CopyTo(avals, 0);
+            Array.Sort(avals);
+            Expect(avals[0], EqualTo("a"));
+            Expect(avals[1], EqualTo("b"));
+        }
+
+
+
+
+        [Test]
+        public void IDictionary_GetEnumerator_returns_an_enumerator()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            IDictionary id = (IDictionary)PersistentArrayMap.create(d);
+            IDictionaryEnumerator e = id.GetEnumerator();
+
+            Expect(e.MoveNext());
+            DictionaryEntry de1 = (DictionaryEntry)e.Current;
+            Expect(e.MoveNext());
+            DictionaryEntry de2 = (DictionaryEntry)e.Current;
+            Expect(e.MoveNext(), False);
+
+            Expect(de1.Key, EqualTo(1) | EqualTo(2));
+            Expect(de2.Key, EqualTo(1) | EqualTo(2));
+            Expect(de1.Value, EqualTo(((int)de1.Key) == 1 ? "a" : "b"));
+            Expect(de2.Value, EqualTo(((int)de2.Key) == 1 ? "a" : "b"));
+        }
+
+        [Test]
+        public void ICollection_CopyTo_Copies()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            ICollection c = (ICollection)PersistentArrayMap.create(d);
+            IMapEntry[] a = new IMapEntry[c.Count];
+            c.CopyTo(a, 0);
+
+            int key0 = (int)a[0].key();
+            int key1 = (int)a[1].key();
+            string val0 = (string)a[0].val();
+            string val1 = (string)a[1].val();
+
+            Expect(key0, EqualTo(1) | EqualTo(2));
+            Expect(key1, EqualTo(key0 == 1 ? 2 : 1));
+            Expect(val0, EqualTo(key0 == 1 ? "a" : "b"));
+            Expect(val1, EqualTo(key1 == 1 ? "a" : "b"));
+        }
+
+
+        [Test]
+        public void ICollection_Count_returns_count_of_items()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            ICollection c = (ICollection)PersistentArrayMap.create(d);
+
+            Expect(c.Count, EqualTo(2));
+        }
+
+        [Test]
+        public void ICollection_IsSynchronized_is_true()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            ICollection c = (ICollection)PersistentArrayMap.create(d);
+
+            Expect(c.IsSynchronized);
+        }
+
+
+        [Test]
+        [ExpectedException(typeof(NotImplementedException))]
+        public void ICollection_SyncRoot_fails()
+        {
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "a";
+            d[2] = "b";
+
+            ICollection c = (ICollection)PersistentArrayMap.create(d);
+
+            object s = c.SyncRoot;
+        }
+
+
+        #endregion
+    }
+
+    [TestFixture]
+    public class PersistentArrayMap_IObj_Tests : IObjTests
+    {
+        MockRepository _mocks;
+
+        [SetUp]
+        public void Setup()
+        {
+            _mocks = new MockRepository();
+            IPersistentMap meta = _mocks.StrictMock<IPersistentMap>();
+            _mocks.ReplayAll();
+
+            Dictionary<int, string> d = new Dictionary<int, string>();
+            d[1] = "abc";
+
+            _objWithNullMeta = (IObj)PersistentArrayMap.create(d);
+            _obj = _objWithNullMeta.withMeta(meta);
+            _expectedType = typeof(PersistentArrayMap);
+        }
+
+        [TearDown]
+        public void Teardown()
+        {
+            _mocks.VerifyAll();
+        }
+
+    }
+
+}
-- 
cgit v1.2.3-18-g5258