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)); }