public void IsSyncRootTest()
{
var target = new MockStringDictionary();
ICollection collection = target;
Assert.IsNotNull(collection.SyncRoot);
}
public void IsSynchronizedTest()
{
var target = new MockStringDictionary();
ICollection collection = target;
Assert.IsFalse(collection.IsSynchronized);
}
public void IndexerSetTest()
{
var target = new MockStringDictionary();
((IDictionary)target)["a"] = "b";
Assert.IsTrue(target.ContainsKey("a"));
}
public void AddTest()
{
var target = new MockStringDictionary();
((IDictionary)target).Add("a", "b");
Assert.IsTrue(target.ContainsKey("a"));
}
public void GetEnumeratorTest()
{
var target = new MockStringDictionary {
{ "a", "b" }, { "s", "r" }, { "f", "t" }
};
ICollection <KeyValuePair <string, string> > dictionary = target;
IEnumerator enumerator = dictionary.GetEnumerator();
enumerator.MoveNext();
var current = (KeyValuePair <string, string>)enumerator.Current;
Assert.AreEqual("a", current.Key);
Assert.AreEqual("b", current.Value);
enumerator.MoveNext();
current = (KeyValuePair <string, string>)enumerator.Current;
Assert.AreEqual("s", current.Key);
Assert.AreEqual("r", current.Value);
enumerator.MoveNext();
current = (KeyValuePair <string, string>)enumerator.Current;
Assert.AreEqual("f", current.Key);
Assert.AreEqual("t", current.Value);
}
public void IsReadOnlyTest()
{
var target = new MockStringDictionary();
ICollection <KeyValuePair <string, string> > collection = target;
Assert.IsFalse(collection.IsReadOnly);
}
public void GetEnumeratorTest()
{
var target = new MockStringDictionary {
{ "a", "b" }, { "s", "r" }, { "f", "t" }
};
IDictionary dictionary = target;
var enumerator = dictionary.GetEnumerator();
enumerator.MoveNext();
var current = (DictionaryEntry)enumerator.Current;
Assert.AreEqual("a", current.Key);
Assert.AreEqual("b", current.Value);
enumerator.MoveNext();
current = (DictionaryEntry)enumerator.Current;
Assert.AreEqual("s", current.Key);
Assert.AreEqual("r", current.Value);
enumerator.MoveNext();
current = (DictionaryEntry)enumerator.Current;
Assert.AreEqual("f", current.Key);
Assert.AreEqual("t", current.Value);
}
public void AddTest()
{
var target = new MockStringDictionary();
ICollection <KeyValuePair <string, string> > collection = target;
collection.Add(new KeyValuePair <string, string>("a", "b"));
Assert.IsTrue(target.ContainsKey("a"));
}
public void IsFixedSizeTest()
{
var target = new MockStringDictionary {
{ "a", "b" }
};
Assert.IsFalse(((IDictionary)target).IsFixedSize);
}
public void IndexerGetTest()
{
var target = new MockStringDictionary {
{ "a", "b" }
};
Assert.AreEqual("b", ((IDictionary)target)["a"]);
}
public void Dictionary()
{
var dictionary = new Dictionary <string, string> {
{ "a", "a" }
};
var target = new MockStringDictionary(dictionary);
Assert.AreEqual(1, target.Count);
}
public void RemoveNonExistingKeyTest()
{
var target = new MockStringDictionary {
{ "a", "a" }
};
ICollection <KeyValuePair <string, string> > collection = target;
Assert.IsFalse(collection.Remove(new KeyValuePair <string, string>("b", "a")));
}
public void RemoveTest()
{
var target = new MockStringDictionary {
{ "a", "b" }
};
((IDictionary)target).Remove("a");
Assert.IsFalse(target.ContainsKey("a"));
}
public void ContainsTest()
{
var target = new MockStringDictionary {
{ "a", "b" }
};
ICollection <KeyValuePair <string, string> > collection = target;
Assert.IsTrue(collection.Contains(new KeyValuePair <string, string>("a", "b")));
Assert.IsFalse(collection.Contains(new KeyValuePair <string, string>("b", "b")));
Assert.IsFalse(collection.Contains(new KeyValuePair <string, string>("a", "c")));
}
public void DictionaryCompare()
{
var dictionary = new Dictionary <string, string> {
{ "a", "a" }
};
var target =
new MockStringDictionary(dictionary, StringComparer.InvariantCultureIgnoreCase);
Assert.AreEqual(StringComparer.InvariantCultureIgnoreCase, target.Comparer);
Assert.AreEqual(1, target.Count);
}
public void ContainsTest()
{
var target = new MockStringDictionary {
{ "a", "b" }
};
IDictionary dictionary = target;
Assert.IsTrue(dictionary.Contains("a"));
Assert.IsFalse(dictionary.Contains("b"));
Assert.IsFalse(dictionary.Contains("c"));
Assert.IsFalse(dictionary.Contains(2));
}
public void ValuesTest()
{
var target = new MockStringDictionary {
{ "a", "b" }, { "f", "s" }, { "g", "z" }
};
var values = target.Values;
Assert.AreEqual(3, values.Count);
Assert.IsTrue(values.Contains("b"));
Assert.IsTrue(values.Contains("s"));
Assert.IsTrue(values.Contains("z"));
}
public void KeysTest()
{
var target = new MockStringDictionary {
{ "a", "b" }, { "f", "b" }, { "g", "b" }
};
var keys = target.Keys;
Assert.AreEqual(3, keys.Count);
Assert.IsTrue(keys.Contains("a"));
Assert.IsTrue(keys.Contains("f"));
Assert.IsTrue(keys.Contains("g"));
}
public void KeysTest()
{
var target = new MockStringDictionary {
{ "a", "b" }, { "f", "b" }, { "g", "b" }
};
var keys = ((IDictionary)target).Keys;
Assert.AreEqual(3, keys.Count);
var strings = new string[3];
keys.CopyTo(strings, 0);
Assert.AreEqual("a", strings[0]);
Assert.AreEqual("f", strings[1]);
Assert.AreEqual("g", strings[2]);
}
public void ValuesTest()
{
var target = new MockStringDictionary {
{ "a", "b" }, { "f", "z" }, { "g", "x" }
};
var values = ((IDictionary)target).Values;
Assert.AreEqual(3, values.Count);
var strings = new string[3];
values.CopyTo(strings, 0);
Assert.AreEqual("b", strings[0]);
Assert.AreEqual("z", strings[1]);
Assert.AreEqual("x", strings[2]);
}
public void CopyToTest()
{
var target = new MockStringDictionary {
{ "a", "b" }, { "g", "s" }, { "h", "x" }
};
ICollection <KeyValuePair <string, string> > collection = target;
var pairs = new KeyValuePair <string, string> [3];
collection.CopyTo(pairs, 0);
Assert.AreEqual("a", pairs[0].Key);
Assert.AreEqual("g", pairs[1].Key);
Assert.AreEqual("h", pairs[2].Key);
Assert.AreEqual("b", pairs[0].Value);
Assert.AreEqual("s", pairs[1].Value);
Assert.AreEqual("x", pairs[2].Value);
}
public void AddInvalidValueTypeTest()
{
var target = new MockStringDictionary();
((IDictionary)target).Add("a", 2);
}
public void IndexerSetInvalidValueTypeTest()
{
var target = new MockStringDictionary();
Assert.Throws <ArgumentException>(() => ((IDictionary)target)["a"] = 2);
}
public void AddInvalidValueTypeTest()
{
var target = new MockStringDictionary();
Assert.Throws <ArgumentException>(() => ((IDictionary)target).Add("a", 2));
}
public void IndexerSetInvalidKeyTypeTest()
{
var target = new MockStringDictionary();
((IDictionary)target)[2] = "a";
}
public void IndexerSetInvalidValueTypeTest()
{
var target = new MockStringDictionary();
((IDictionary)target)["a"] = 2;
}
public void IsReadOnlyTest()
{
var target = new MockStringDictionary();
Assert.IsFalse(((IDictionary)target).IsReadOnly);
}
public void AddInvalidKeyTypeTest()
{
var target = new MockStringDictionary();
((IDictionary)target).Add(2, "a");
}
public void CapacityComparer()
{
var target = new MockStringDictionary(1, StringComparer.InvariantCultureIgnoreCase);
Assert.AreEqual(StringComparer.InvariantCultureIgnoreCase, target.Comparer);
}