public void CreateOnNoArgsReturnsEmptyMap()
{
PersistentHashMap m = PersistentHashMap.create();
Expect(m.count(), EqualTo(0));
Expect(m.meta(), Null);
}
public void DoBigTest(int numEntries)
{
System.Console.WriteLine("Testing {0} items.", numEntries);
Random rnd = new Random();
Dictionary <int, int> dict = new Dictionary <int, int>(numEntries);
for (int i = 0; i < numEntries; i++)
{
int r = rnd.Next();
dict[r] = r;
}
PersistentHashMap m = (PersistentHashMap)PersistentHashMap.create(dict);
Expect(m.count()).To.Equal(dict.Count);
foreach (int key in dict.Keys)
{
Expect(m.containsKey(key));
Expect(m.valAt(key)).To.Equal(key);
}
for (ISeq s = m.seq(); s != null; s = s.next())
{
Expect(dict.ContainsKey((int)((IMapEntry)s.first()).key()));
}
}
public void CreateOnNoArgsReturnsEmptyMap()
{
PersistentHashMap m = PersistentHashMap.create();
Expect(m.count()).To.Equal(0);
Expect(m.meta()).To.Be.Null();
}
public void CreateOnEmptyDictionaryReturnsEmptyMap()
{
Dictionary <int, string> d = new Dictionary <int, string>();
IPersistentMap m = PersistentHashMap.create(d);
Expect(m.count()).To.Equal(0);
}
public void CreateOnEmptyListReturnsEmptyMap()
{
ArrayList a = new ArrayList();
IPersistentMap m = PersistentHashMap.create1(a);
Expect(m.count()).To.Equal(0);
}
public void Setup()
{
IPersistentMap meta = PersistentHashMap.create("a", 1, "b", 2);
_s = StringSeq.create("abcde");
_sWithMeta = (StringSeq)((IObj)StringSeq.create("abcde")).withMeta(meta);
_values = new object[] { 'a', 'b', 'c', 'd', 'e' };
}
public void Setup()
{
IPersistentMap meta = PersistentHashMap.create("a", 1, "b", 2);
_r = new Range(2, 5);
_rWithMeta = new Range(meta, 2, 5);
_values = new object[] { 2, 3, 4 };
}
public void RetriveValueWithUnknownKeyViaValAt()
{
IPersistentMap <string, string> target = new PersistentHashMap <string, string>();
target = target.Assoc("a", "b");
target.ValAt("x");
}
public void RetriveValueWithUnknownKeyForPrimitiveTypesViaValAt()
{
IPersistentMap <int, int> target = new PersistentHashMap <int, int>();
target = target.Assoc(1, 2);
target.ValAt(3);
}
public void Setup()
{
IPersistentMap meta = PersistentHashMap.create("a", 1, "b", 2);
_r = (Range)Range.create(2L, 5L);
_rWithMeta = (Range)_r.withMeta(meta);
_values = new object[] { 2, 3, 4 };
}
void DoEmit(RHC rhc, ObjExpr objx, CljILGen ilg, bool emitUnboxed)
{
List <LocalBuilder> locals = new List <LocalBuilder>();
for (int i = 0; i < _bindingInits.count(); i++)
{
BindingInit bi = (BindingInit)_bindingInits.nth(i);
Type primType = Compiler.MaybePrimitiveType(bi.Init);
if (primType != null)
{
LocalBuilder local = ilg.DeclareLocal(primType);
locals.Add(local);
GenContext.SetLocalName(local, bi.Binding.Name);
bi.Binding.LocalVar = local;
((MaybePrimitiveExpr)bi.Init).EmitUnboxed(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Stloc, local);
}
else
{
LocalBuilder local = ilg.DeclareLocal(typeof(Object));
locals.Add(local);
GenContext.SetLocalName(local, bi.Binding.Name);
bi.Binding.LocalVar = local;
bi.Init.Emit(RHC.Expression, objx, ilg);
ilg.Emit(OpCodes.Stloc, local);
}
}
Label loopLabel = ilg.DefineLabel();
ilg.MarkLabel(loopLabel);
try
{
if (_isLoop)
{
Var.pushThreadBindings(PersistentHashMap.create(Compiler.LoopLabelVar, loopLabel));
}
if (emitUnboxed)
{
((MaybePrimitiveExpr)_body).EmitUnboxed(rhc, objx, ilg);
}
else
{
_body.Emit(rhc, objx, ilg);
}
}
finally
{
if (_isLoop)
{
Var.popThreadBindings();
}
}
}
public void CreateOnMetaNoArgsReturnsEmptyMap()
{
IPersistentMap meta = new DummyMeta();
PersistentHashMap m = PersistentHashMap.create(meta);
Expect(m.count()).To.Equal(0);
Expect(Object.ReferenceEquals(m.meta(), meta));
}
public void CreateOnMetaNoArgsReturnsEmptyMap()
{
IPersistentMap meta = new DummyMeta();
PersistentHashMap m = PersistentHashMap.create(meta);
Expect(m.count(), EqualTo(0));
Expect(m.meta(), SameAs(meta));
}
public void Setup()
{
PersistentList p1 = new PersistentList("abc");
PersistentList p2 = (PersistentList)p1.cons("def");
_pl = (PersistentList)p2.cons(7);
_values = new object[] { 7, "def", "abc" };
_plWithMeta = (PersistentList)_pl.withMeta(PersistentHashMap.create("a", 1));
}
public void CreateOnEmptyISeqReturnsEmptyMap()
{
object[] items = new object[] {};
ArrayList a = new ArrayList(items);
ISeq s = PersistentList.create(a).seq();
IPersistentMap m = PersistentHashMap.create(s);
Expect(m.count()).To.Equal(0);
}
private Expression GenCode(RHC rhc, ObjExpr objx, GenContext context, bool genUnboxed)
{
LabelTarget loopLabel = Expression.Label();
List <ParameterExpression> parms = new List <ParameterExpression>();
List <Expression> forms = new List <Expression>();
for (int i = 0; i < _bindingInits.count(); i++)
{
BindingInit bi = (BindingInit)_bindingInits.nth(i);
Type primType = Compiler.MaybePrimitiveType(bi.Init);
ParameterExpression parmExpr;
Expression initExpr;
if (primType != null)
{
parmExpr = Expression.Parameter(primType, bi.Binding.Name);
initExpr = ((MaybePrimitiveExpr)bi.Init).GenCodeUnboxed(RHC.Expression, objx, context);
}
else
{
parmExpr = Expression.Parameter(typeof(object), bi.Binding.Name);
initExpr = Compiler.MaybeBox(bi.Init.GenCode(RHC.Expression, objx, context));
}
bi.Binding.ParamExpression = parmExpr;
parms.Add(parmExpr);
forms.Add(Expression.Assign(parmExpr, initExpr));
}
forms.Add(Expression.Label(loopLabel));
try
{
if (_isLoop)
{
Var.pushThreadBindings(PersistentHashMap.create(Compiler.LoopLabelVar, loopLabel));
}
Expression form = genUnboxed
? ((MaybePrimitiveExpr)_body).GenCodeUnboxed(rhc, objx, context)
: _body.GenCode(rhc, objx, context);
forms.Add(form);
}
finally
{
if (_isLoop)
{
Var.popThreadBindings();
}
}
Expression block = Expression.Block(parms, forms);
return(block);
}
public IPersistentMap persistent()
{
var hashMap = new Dictionary <object, object>();
foreach (KeyValuePair <string, object> kvp in this)
{
hashMap.Add(Keyword.intern(kvp.Key), kvp.Value);
}
return(PersistentHashMap.create(hashMap));
}
public void CreateOnNoArgsReturnsMap()
{
PersistentHashMap m = PersistentHashMap.create(1, "a", 2, "b");
Expect(m.count(), EqualTo(2));
Expect(m.valAt(1), EqualTo("a"));
Expect(m.valAt(2), EqualTo("b"));
Expect(m.containsKey(3), False);
Expect(m.meta(), Null);
}
public void CreateOnNoArgsReturnsMap()
{
PersistentHashMap m = PersistentHashMap.create(1, "a", 2, "b");
Expect(m.count()).To.Equal(2);
Expect(m.valAt(1)).To.Equal("a");
Expect(m.valAt(2)).To.Equal("b");
Expect(m.containsKey(3)).To.Be.False();
Expect(m.meta()).To.Be.Null();
}
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);
}
public void Setup()
{
IPersistentMap meta = new DummyMeta();
PersistentHashMap m = PersistentHashMap.create(1, "a", 2, "b");
_testNoChange = false;
_objWithNullMeta = (IObj)m;
_obj = _objWithNullMeta.withMeta(meta);
_expectedType = typeof(PersistentHashMap);
}
// ==================================================================
// Persistent maps
public static IPersistentMap Zipmap(object[] ks, object[] vs)
{
var len = Mathf.Min(ks.Length, vs.Length) * 2;
object[] kvs = new object[len];
for (int i = 0; i < len; i += 2)
{
kvs[i] = ks[i / 2];
kvs[i + 1] = vs[i / 2];
}
return(PersistentHashMap.create(kvs));
}
public void CreatePersistentHashMapFromDictonary()
{
var dict = new Dictionary <Int32, Int32>();
dict[1] = 1;
dict[3] = 3;
var target = new PersistentHashMap <Int32, Int32>(dict);
Assert.AreEqual(1, target.ValAt(1));
Assert.AreEqual(3, target.ValAt(3));
}
public void CreateOnMetaNoArgsReturnsMap()
{
IPersistentMap meta = new DummyMeta();
PersistentHashMap m = PersistentHashMap.create(meta, 1, "a", 2, "b");
Expect(m.count(), EqualTo(2));
Expect(m.valAt(1), EqualTo("a"));
Expect(m.valAt(2), EqualTo("b"));
Expect(m.containsKey(3), False);
Expect(m.meta(), SameAs(meta));
}
public void CreateOnListReturnsMap()
{
object[] items = new object[] { 1, "a", 2, "b" };
ArrayList a = new ArrayList(items);
IPersistentMap m = PersistentHashMap.create1(a);
Expect(m.count(), EqualTo(2));
Expect(m.valAt(1), EqualTo("a"));
Expect(m.valAt(2), EqualTo("b"));
Expect(m.containsKey(3), False);
}
public void CreateOnISeqReturnsMap()
{
object[] items = new object[] { 1, "a", 2, "b" };
ArrayList a = new ArrayList(items);
ISeq s = PersistentList.create(a).seq();
IPersistentMap m = PersistentHashMap.create(s);
Expect(m.count()).To.Equal(2);
Expect(m.valAt(1)).To.Equal("a");
Expect(m.valAt(2)).To.Equal("b");
Expect(m.containsKey(3)).To.Be.False();
}
public void CreateOnMetaNoArgsReturnsMap()
{
IPersistentMap meta = new DummyMeta();
PersistentHashMap m = PersistentHashMap.create(meta, 1, "a", 2, "b");
Expect(m.count()).To.Equal(2);
Expect(m.valAt(1)).To.Equal("a");
Expect(m.valAt(2)).To.Equal("b");
Expect(m.containsKey(3)).To.Be.False();
Expect(Object.ReferenceEquals(m.meta(), meta));
}
[SetUp]
public void Setup()
{
_tw = new StringWriter();
_obj = _proxyType.GetConstructor(Type.EmptyTypes).Invoke(Array.Empty<object>());
IProxy ip = _obj as IProxy;
ip.__initClojureFnMappings(
PersistentHashMap.create(
"Flush", new FlushFn(),
"Close", new CloseFn(),
"Write", new WriteFn()
));
public void CreateOnMetaNoArgsReturnsEmptyMap()
{
MockRepository mocks = new MockRepository();
IPersistentMap meta = mocks.StrictMock <IPersistentMap>();
mocks.ReplayAll();
PersistentHashMap m = PersistentHashMap.create(meta);
Expect(m.count(), EqualTo(0));
Expect(m.meta(), SameAs(meta));
mocks.VerifyAll();
}
public clojure.lang.IPersistentMap ToPersistentMap(object mutInst, IFn processElement)
{
var len = dict.Count * 2;
var kvs = new object[len];
int i = 0;
foreach (var kv in dict)
{
kvs[i] = kv.Key;
kvs[i + 1] = processElement.invoke(mutInst, kv.Key, kv.Value);
i += 2;
}
return(PersistentHashMap.create(kvs));
}
