public void Dictionary()
{
DictionaryClass a = new DictionaryClass
{
Strings = new Dictionary <string, string>
{
{ "1", "test1" },
{ "2", "test2" },
}
};
XmlDocument target = new XmlDocument();
Serializer.Serialize((SystemXmlAdapter)target, a);
Assert.AreEqual(1, target.DocumentElement.ChildNodes.Count);
DictionaryClass b = Deserializer.Deserialize <DictionaryClass>((SystemXmlAdapter)target);
Assert.AreEqual(a.Strings.Count, b.Strings.Count);
foreach (KeyValuePair <string, string> pair in a.Strings)
{
Assert.AreEqual(pair.Value, b.Strings[pair.Key]);
}
}
public void TestAdd()
{
DictionaryClass<string, int> d = new DictionaryClass<string, int>(3);
d.Add("cats", 1);
d.Add("birds", 14);
Assert.AreEqual(2, d.Count);
}
public void FindAWordInDictionaryWithTwoWordsWithSameHash()
{
var dictionary = new DictionaryClass<string, string>();
dictionary.Add("apple", "apple");
dictionary.Add("apple", "pear");
dictionary.ContainsKey("apple").ShouldBeTrue();
}
public void Dictionary()
{
DictionaryClass a = new DictionaryClass
{
Strings = new Dictionary <string, string>
{
{ "1", "test1" },
{ "2", "test2" },
}
};
JObject target = new JObject();
Serializer.Serialize((NewtonsoftJsonAdapter)target, a);
AssertChildren(3, target);
DictionaryClass b = Deserializer.Deserialize <DictionaryClass>((NewtonsoftJsonAdapter)target);
Assert.AreEqual(a.Strings.Count, b.Strings.Count);
foreach (KeyValuePair <string, string> pair in a.Strings)
{
Assert.AreEqual(pair.Value, b.Strings[pair.Key]);
}
}
public void FindASpecificWordInDictionaryWithTwoWordsWithSameHash()
{
var dictionary = new DictionaryClass<string, string>();
dictionary.Add("apple", "apple");
dictionary.Add("apple", "pear");
var word = dictionary.Find("apple");
word.ShouldEqual("apple");
}
public void VerifyAddANewValueInDictionary()
{
var newEntry = new NewEntry("apple", "It is a fruit");
var newEntry2 = new NewEntry("pear", "It is a fruit");
var dictionary = new DictionaryClass<string, NewEntry>();
dictionary.Add(newEntry.Name, newEntry);
dictionary.Add(newEntry2.Name, newEntry2);
}
public void DictionaryToIDictionaryIsReferenceEqual()
{
var mapper = new MemberMapper();
var source = new DictionaryClass { Foo = new Dictionary<int, string>() };
var result = mapper.Map(source, new IDictionaryClass());
Assert.IsTrue(object.ReferenceEquals(source.Foo, result.Foo));
}
public void TestContainsKey()
{
DictionaryClass<string, int> d = new DictionaryClass<string, int>(2);
d.Add("cats", 1);
d.Add("birds", 14);
d.Add("cows", 5);
Assert.AreEqual(true, d.ContainsKey("cats"));
Assert.AreEqual(false, d.ContainsKey("sheeps"));
}
public void DictionaryToIDictionaryIsReferenceEqual()
{
var mapper = new MemberMapper();
var source = new DictionaryClass {
Foo = new Dictionary <int, string>()
};
var result = mapper.Map(source, new IDictionaryClass());
Assert.IsTrue(object.ReferenceEquals(source.Foo, result.Foo));
}
public void VerifyFindAStructureWithSameHashCodeDictionary()
{
var dictionary = new DictionaryClass<string, NewEntry>();
var newEntry = new NewEntry("apple", "It is a fruit");
var newEntry2 = new NewEntry("tomato", "It is a vegetable");
dictionary.Add(newEntry.Name, newEntry);
dictionary.Add(newEntry2.Name, newEntry2);
var word = dictionary.Find(newEntry2.Name);
word.ShouldEqual<NewEntry>(newEntry2);
}
public void TestClear()
{
DictionaryClass<string, int> d = new DictionaryClass<string, int>(2);
d.Add("cats", 1);
d.Add("birds", 14);
d.Add("cows", 5);
d.Clear();
Assert.AreEqual(0, d.Count);
}
public void DontPreserveContents_MappingDictionaryToConcurrentDictionaryWorks()
{
var mapper = new MemberMapper();
mapper.Options.Conventions.PreserveDestinationListContents = false;
var source = new DictionaryClass { Foo = new Dictionary<int, string>() { { 1, "test" } } };
var result = mapper.Map(source, new ConcurrentDictionaryClass());
Assert.AreEqual("test", result.Foo[1]);
}
public void VerifyAddANewValueInEmptyDictionary()
{
var newEntry = new NewEntry("apple", "It is a fruit");
var newEntry2 = new NewEntry("pear", "It is a fruit");
var newEntry3 = new NewEntry("tomato", "It is a vegetable");
var dictionary = new DictionaryClass<string, NewEntry>();
dictionary.Add(newEntry.Name, newEntry);
dictionary.Add(newEntry2.Name, newEntry2);
dictionary.Add(newEntry3.Name, newEntry3);
dictionary.Count.ShouldEqual(3);
}
public void DontPreserveContents_MappingDictionaryToICollectionWorks()
{
var mapper = new MemberMapper();
mapper.Options.Conventions.PreserveDestinationListContents = false;
var source = new DictionaryClass { Foo = new Dictionary<int, string>() { { 1, "test" } } };
var result = mapper.Map(source, new ICollectionClass() { Foo = new List<string> { "test1" } });
Assert.AreEqual("test", result.Foo.First());
}
public void TestGetValueByKey()
{
DictionaryClass<string, int> d = new DictionaryClass<string, int>(2);
d.Add("cats", 1);
d.Add("birds", 14);
d.Add("cows", 5);
Assert.AreEqual(5, d["cows"]);
Assert.AreEqual(1, d["cats"]);
Assert.AreNotEqual(7, d["cats"]);
}
public void DictionaryAddAndCount()
{
string randomTitle = "Random title";
DictionaryClass<int, string> myDictionaryList = new DictionaryClass<int, string>();
//myDictionaryList.Add(new KeyValuePair<int, string>(hashCode, randomTitle));
myDictionaryList.Add(randomTitle);
myDictionaryList.Add("Random title 2");
Assert.AreEqual(2, myDictionaryList.Count);
}
public void DontPreserveContents_DictionaryToIDictionaryIsReferenceEqual()
{
var mapper = new MemberMapper();
mapper.Options.Conventions.PreserveDestinationListContents = false;
var source = new DictionaryClass { Foo = new Dictionary<int, string>() };
var result = mapper.Map(source, new IDictionaryClass());
Assert.IsTrue(object.ReferenceEquals(source.Foo, result.Foo));
}
public void DictionaryContainsValue()
{
string randomTitle = "Random title";
DictionaryClass<int, string> myDictionaryList = new DictionaryClass<int, string>();
//myDictionaryList.Add(new KeyValuePair<int, string>(hashCode, randomTitle));
myDictionaryList.Add(randomTitle);
myDictionaryList.Add("Random title 2");
Assert.AreEqual(true, myDictionaryList.ContainsValue("Random title 2"));
Assert.AreNotEqual(true, myDictionaryList.ContainsValue("Random title 3"));
}
public void DontPreserveContents_DictionaryToIDictionaryIsReferenceEqual()
{
var mapper = new MemberMapper();
mapper.Options.Conventions.PreserveDestinationListContents = false;
var source = new DictionaryClass {
Foo = new Dictionary <int, string>()
};
var result = mapper.Map(source, new IDictionaryClass());
Assert.IsTrue(object.ReferenceEquals(source.Foo, result.Foo));
}
public void TestForeach()
{
DictionaryClass<string, int> d = new DictionaryClass<string, int>(3);
d.Add("cats", 1);
d.Add("birds", 14);
d.Add("cows", 5);
int count = 0;
foreach (KeyValuePair<string, int> key in d)
{
count++;
}
Assert.AreEqual(3, count);
}
public void MappingDictionaryToConcurrentDictionaryWorks()
{
var mapper = new MemberMapper();
var source = new DictionaryClass {
Foo = new Dictionary <int, string>()
{
{ 1, "test" }
}
};
var result = mapper.Map(source, new ConcurrentDictionaryClass());
Assert.AreEqual("test", result.Foo[1]);
}
public void TestAutoIncreaseEntries()
{
DictionaryClass<string, int> d = new DictionaryClass<string, int>(2);
d.Add("cats", 1);
d.Add("birds", 14);
d.Add("cows", 5);
d.Remove("birds");
d.Add("fish", 33);
d.Add("sheeps", 68);
d.Add("chickens", 21);
Assert.AreEqual(5, d.Count);
}
public void MappingDictionaryToArrayWorks()
{
var mapper = new MemberMapper();
var source = new DictionaryClass {
Foo = new Dictionary <int, string>()
{
{ 1, "test" }
}
};
var result = mapper.Map(source, new ArrayClass()
{
Foo = new [] { "test1" }
});
Assert.AreEqual("test", result.Foo[0]);
}
public void DontPreserveContents_MappingDictionaryToConcurrentDictionaryWorks()
{
var mapper = new MemberMapper();
mapper.Options.Conventions.PreserveDestinationListContents = false;
var source = new DictionaryClass {
Foo = new Dictionary <int, string>()
{
{ 1, "test" }
}
};
var result = mapper.Map(source, new ConcurrentDictionaryClass());
Assert.AreEqual("test", result.Foo[1]);
}
public void MappingDictionaryToICollectionWorks()
{
var mapper = new MemberMapper();
var source = new DictionaryClass {
Foo = new Dictionary <int, string>()
{
{ 1, "test" }
}
};
var result = mapper.Map(source, new ICollectionClass()
{
Foo = new List <string> {
"test1"
}
});
Assert.AreEqual("test1", result.Foo.ElementAt(0));
Assert.AreEqual("test", result.Foo.ElementAt(1));
}
public void DontPreserveContents_MappingDictionaryToICollectionWorks()
{
var mapper = new MemberMapper();
mapper.Options.Conventions.PreserveDestinationListContents = false;
var source = new DictionaryClass {
Foo = new Dictionary <int, string>()
{
{ 1, "test" }
}
};
var result = mapper.Map(source, new ICollectionClass()
{
Foo = new List <string> {
"test1"
}
});
Assert.AreEqual("test", result.Foo.First());
}
public void CanAccessDictionnaryKeysAsProperties()
{
var dict = new DictionaryClass();
dict.Dictionary["element"] = "yeah";
var dictionary = new Dictionary <string, int>();
dictionary["one"] = 1;
dictionary["two"] = 2;
dictionary["three"] = 3;
dictionary["four"] = 4;
var resolver = new Resolver();
resolver.SetParameter("i", dictionary);
resolver.SetParameter("dict", dict);
var result = resolver.Resolve("-> [dict.Dictionary.element] [i.one] [i.two] [i.three] [i.four] <-");
Assert.That(result, Is.EqualTo("-> yeah 1 2 3 4 <-"));
}
public void Dictionaries()
{
Assert.True(PropertyBasedSerializationSurrogate.CanHandle(typeDataCache, FudgeFieldNameConvention.Identity, typeof(DictionaryClass)));
var serializer = new FudgeSerializer(context); // We're relying on it auto-discovering the type surrogate
var obj1 = new DictionaryClass();
obj1.Map = new Dictionary <string, SimpleExampleClass>();
obj1.Map["Fred"] = new SimpleExampleClass {
Name = "Fred", Age = 23
};
obj1.Map["Jemima"] = new SimpleExampleClass {
Name = "Jemima", Age = 17
};
var msg = serializer.SerializeToMsg(obj1);
var obj2 = (DictionaryClass)serializer.Deserialize(msg);
Assert.NotSame(obj1, obj2);
Assert.NotSame(obj1.Map, obj2.Map);
Assert.Equal(obj1.Map["Fred"], obj2.Map["Fred"]);
Assert.Equal(obj1.Map["Jemima"], obj2.Map["Jemima"]);
}
public void DictionaryIsEmpty()
{
DictionaryClass<int, string> myDictionaryList = new DictionaryClass<int, string>();
Assert.AreEqual(true, myDictionaryList.IsEmpty());
}
public void TestRemoveByKey()
{
DictionaryClass<string, int> d = new DictionaryClass<string, int>(2);
d.Add("cats", 1);
d.Add("birds", 14);
d.Add("cows", 5);
d.Remove("birds");
Assert.AreEqual(0, d["birds"]);
Assert.AreEqual(0, d["fish"]);
Assert.AreEqual(2, d.Count);
}
public void TestCount()
{
DictionaryClass<string, int> d = new DictionaryClass<string, int>(13);
Assert.AreEqual(0, d.Count);
}
public void Dictionaries()
{
Assert.True(PropertyBasedSerializationSurrogate.CanHandle(typeDataCache, FudgeFieldNameConvention.Identity, typeof(DictionaryClass)));
var serializer = new FudgeSerializer(context); // We're relying on it auto-discovering the type surrogate
var obj1 = new DictionaryClass();
obj1.Map = new Dictionary<string, SimpleExampleClass>();
obj1.Map["Fred"] = new SimpleExampleClass { Name = "Fred", Age = 23 };
obj1.Map["Jemima"] = new SimpleExampleClass { Name = "Jemima", Age = 17 };
var msg = serializer.SerializeToMsg(obj1);
var obj2 = (DictionaryClass)serializer.Deserialize(msg);
Assert.NotSame(obj1, obj2);
Assert.NotSame(obj1.Map, obj2.Map);
Assert.Equal(obj1.Map["Fred"], obj2.Map["Fred"]);
Assert.Equal(obj1.Map["Jemima"], obj2.Map["Jemima"]);
}
public void MappingDictionaryToICollectionWorks()
{
var mapper = new MemberMapper();
var source = new DictionaryClass { Foo = new Dictionary<int, string>() { { 1, "test" } } };
var result = mapper.Map(source, new ICollectionClass() { Foo = new List<string> { "test1" } });
Assert.AreEqual("test1", result.Foo.ElementAt(0));
Assert.AreEqual("test", result.Foo.ElementAt(1));
}
public void MappingDictionaryToConcurrentDictionaryWorks()
{
var mapper = new MemberMapper();
var source = new DictionaryClass { Foo = new Dictionary<int, string>() { { 1, "test" } } };
var result = mapper.Map(source, new ConcurrentDictionaryClass());
Assert.AreEqual("test", result.Foo[1]);
}
public void MappingDictionaryToListWorks()
{
var mapper = new MemberMapper();
var source = new DictionaryClass { Foo = new Dictionary<int, string>() { { 1, "test" } } };
var result = mapper.Map(source, new ListClass() { Foo = new List<string> { "test1" } });
Assert.AreEqual("test1", result.Foo[0]);
Assert.AreEqual("test", result.Foo[1]);
}
public void LoadBuiltinClasses()
{
classes["Int"] = new IntClass();
classes["Float"] = new FloatClass();
classes["Boolean"] = new BooleanClass();
classes["String"] = new StringClass();
classes["Char"] = new CharClass();
classes["Byte"] = new ByteClass();
classes["Message"] = new MessageClass();
classes["Unassigned"] = new UnassignedClass();
classes["Tuple"] = new TupleClass();
classes["NameValue"] = new NameValueClass();
classes["Lambda"] = new LambdaClass();
classes["Void"] = new VoidClass();
classes["Some"] = new SomeClass();
classes["None"] = new NoneClass();
classes["Array"] = new ArrayClass();
classes["Iterator"] = new IteratorClass();
classes["LazyIterator"] = new LazyIteratorClass();
classes["StreamIterator"] = new StreamIteratorClass();
classes["Any"] = new AnyClass();
classes["Placeholder"] = new PlaceholderClass();
classes["Range"] = new RangeClass();
classes["Dictionary"] = new DictionaryClass();
classes["Container"] = new ContainerClass();
classes["Unmatched"] = new UnmatchedClass();
classes["Complex"] = new ComplexClass();
classes["Rational"] = new RationalClass();
classes["Long"] = new LongClass();
classes["Lazy"] = new LazyClass();
classes["YieldingInvokable"] = new YieldingInvokableClass();
classes["Del"] = new DelClass();
classes["Slice"] = new SliceClass();
classes["End"] = new EndClass();
classes["List"] = new ListClass();
classes["Arguments"] = new ArgumentsClass();
classes["Symbol"] = new SymbolClass();
classes["Infinity"] = new InfinityClass();
classes["OpenRange"] = new OpenRangeClass();
classes["KeyValue"] = new KeyValueClass();
classes["Regex"] = new RegexClass();
classes["Pattern"] = new PatternClass();
classes["PackageFunction"] = new PackageFunctionClass();
classes["Sys"] = new SysClass();
classes["Math"] = new MathClass();
classes["RuntimeFunction"] = new RuntimeFunctionClass();
classes["Reference"] = new ReferenceClass();
classes["Group"] = new RegexGroupClass();
classes["Match"] = new RegexMatchClass();
classes["Date"] = new DateClass();
classes["Interval"] = new IntervalClass();
classes["TypeConstraint"] = new TypeConstraintClass();
classes["ByteArray"] = new ByteArrayClass();
classes["Selector"] = new SelectorClass();
classes["Number"] = new NumberClass();
classes["Collection"] = new CollectionClass();
classes["TextFinding"] = new TextFindingClass();
classes["SkipTake"] = new SkipTakeClass();
classes["Constructor"] = new ConstructorClass();
classes["MutString"] = new MutStringClass();
classes["Error"] = new ErrorClass();
classes["Success"] = new SuccessClass();
classes["Failure"] = new FailureClass();
classes["Optional"] = new OptionalClass();
classes["Result"] = new ResultClass();
classes["Monad"] = new MonadClass();
classes["Unit"] = new UnitClass();
classes["YieldReturn"] = new YieldReturnClass();
classes["Index"] = new IndexClass();
classes["Cycle"] = new CycleClass();
classes["Set"] = new SetClass();
}
public void FindAWordInDictionaryWithOneWord()
{
var dictionary = new DictionaryClass<string, string>();
dictionary.Add("apple", "apple");
dictionary.ContainsKey("apple").ShouldBeTrue();
}
public void FindAWordInEmptyDictionary()
{
var newEntry = new NewEntry("apple", "It is a fruit");
var dictionary = new DictionaryClass<string, NewEntry>();
dictionary.ContainsKey(newEntry.Name).ShouldBeFalse();
}
public void VerifyEmptyDictionary()
{
var dictionary = new DictionaryClass<string, string>();
dictionary.ShouldBeEmpty();
}
