public void Test01()
{
MyNameObjectCollection noc = new MyNameObjectCollection();
NameObjectCollectionBase.KeysCollection keys;
// Set up initial collection
for (int i = 0; i < 20; i++)
{
noc.Add("key_" + i.ToString(), new Foo());
}
// Get the KeysCollection
_strErr = "Err_001, ";
keys = noc.Keys;
// Check Count
if (keys.Count != noc.Count)
{
Assert.False(true, string.Format(_strErr + "keys.Count is wrong. expected {0}, got {1}", noc.Count, keys.Count));
}
// Compare - test Get, Item
for (int i = 0; i < noc.Count; i++)
{
if (keys.Get(i) != "key_" + i.ToString())
{
Assert.False(true, string.Format(_strErr + "keys.Get({0}) is wrong. expected {1}, got {2}", i, "key_" + i.ToString(), keys.Get(i)));
}
if (keys[i] != "key_" + i.ToString())
{
Assert.False(true, string.Format(_strErr + "keys[{0}] is wrong. expected {1}, got {2}", i, "key_" + i.ToString(), keys[i]));
}
}
// Get enumerator - it's the same enumerator as the original collection, so don't
// need to test it again here.
IEnumerator en = keys.GetEnumerator();
// Get SyncRoot - just a cursory test
if (((ICollection)keys).SyncRoot != ((ICollection)noc).SyncRoot)
{
Assert.False(true, _strErr + "keys.SyncRoot was not the same as noc.SyncRoot");
}
// Get IsSynchronized
if (((ICollection)keys).IsSynchronized)
{
Assert.False(true, _strErr + "keys.SyncRoot was not the same as noc.SyncRoot");
}
// Check empty collection
noc = new MyNameObjectCollection();
keys = noc.Keys;
// Check Count
if (keys.Count != 0)
{
Assert.False(true, string.Format(_strErr + "keys.Count is wrong. expected {0}, got {1}", 0, keys.Count));
}
}
public void RemoveAt_InvalidIndex_ThrowsArgumentOutOfRangeException(int count)
{
MyNameObjectCollection nameObjectCollection = Helpers.CreateNameObjectCollection(count);
AssertExtensions.Throws <ArgumentOutOfRangeException>("index", () => nameObjectCollection.RemoveAt(-1));
AssertExtensions.Throws <ArgumentOutOfRangeException>("index", () => nameObjectCollection.RemoveAt(count));
}
public void CopyTo(int count, int index)
{
MyNameObjectCollection nameObjectCollection = Helpers.CreateNameObjectCollection(count);
ICollection collection = nameObjectCollection;
string[] copyArray = new string[index + collection.Count + index];
collection.CopyTo(copyArray, index);
for (int i = 0; i < index; i++)
{
Assert.Null(copyArray[i]);
}
for (int i = 0; i < count; i++)
{
Assert.Equal(nameObjectCollection.GetKey(i), copyArray[i + index]);
}
for (int i = index + collection.Count; i < copyArray.Length; i++)
{
Assert.Null(copyArray[i]);
}
// Clearing the nameObjectCollection should not affect the keys copy
int previousCount = copyArray.Length;
nameObjectCollection.Clear();
Assert.Equal(previousCount, copyArray.Length);
}
public void RemoveAt_ReadOnly_ThrowsNotSupportedException()
{
MyNameObjectCollection nameObjectCollection = Helpers.CreateNameObjectCollection(1);
nameObjectCollection.IsReadOnly = true;
Assert.Throws <NotSupportedException>(() => nameObjectCollection.RemoveAt(0));
}
private static void Keys_CopyTo_Helper(MyNameObjectCollection nameObjectCollection, int index)
{
ICollection keys = nameObjectCollection.Keys;
string[] keysArray = new string[index + keys.Count + index];
keys.CopyTo(keysArray, index);
for (int i = 0; i < index; i++)
{
Assert.Null(keysArray[i]);
}
for (int i = 0; i < keys.Count; i++)
{
Assert.Equal(nameObjectCollection.GetKey(i), keysArray[i + index]);
}
for (int i = index + keys.Count; i < keysArray.Length; i++)
{
Assert.Null(keysArray[i]);
}
// Clearing the nameObjectCollection should not affect the keys copy
int previousCount = keysArray.Length;
nameObjectCollection.Clear();
Assert.Equal(previousCount, keysArray.Length);
}
void CheckCollection(MyNameObjectCollection noc, ArrayList keys, ArrayList values)
{
// Check counts
if ((noc.Count != keys.Count) || (noc.Count != values.Count))
{
Assert.False(true, _strErr + "Wrong number of elements, or mismatched keys and values.");
Assert.False(true, string.Format(_strErr + "noc.Count={0}, keys.Count={1}, values.Count={2}", noc.Count, keys.Count, values.Count));
}
// Check keys/values
for (int i = 0; i < noc.Count; i++)
{
// keys
if (noc.GetKey(i) != (String)keys[i])
{
Assert.False(true, string.Format(_strErr + "key #{0} not as expected. noc.GetKey({0}) = {1}, should be {2}", i, noc.GetKey(i), keys[i]));
}
// values
if (values[i] == null)
{
if (noc[i] != null)
{
Assert.False(true, string.Format(_strErr + "value #{0} not as expected. noc[{0}] = {1}, should be {2}", i, noc[i], values[i]));
}
}
else
{
if ((noc[i] == null) || ((Foo)noc[i] != (Foo)values[i]))
{
Assert.False(true, string.Format(_strErr + "value #{0} not as expected. noc[{0}] = {1}, should be {2}", i, noc[i], values[i]));
}
}
}
}
public static void GetAllValues_Invalid()
{
MyNameObjectCollection nameObjectCollection = new MyNameObjectCollection();
Assert.Throws<ArgumentNullException>("type", () => nameObjectCollection.GetAllValues(null));
nameObjectCollection.Add("name", new Foo("value"));
Assert.Throws<ArrayTypeMismatchException>(() => nameObjectCollection.GetAllValues(typeof(string)));
}
public void Keys_Properties(int count)
{
MyNameObjectCollection nameObjectCollection = Helpers.CreateNameObjectCollection(count);
ICollection keysCollection = nameObjectCollection.Keys;
Assert.Same(((ICollection)nameObjectCollection).SyncRoot, keysCollection.SyncRoot);
Assert.False(keysCollection.IsSynchronized);
}
public static void GetAllValues_Invalid()
{
MyNameObjectCollection nameObjectCollection = new MyNameObjectCollection();
AssertExtensions.Throws <ArgumentNullException>("type", () => nameObjectCollection.GetAllValues(null));
nameObjectCollection.Add("name", new Foo("value"));
Assert.Throws <ArrayTypeMismatchException>(() => nameObjectCollection.GetAllValues(typeof(string)));
}
public void Constructor_Provider_Comparer()
{
#pragma warning disable CS0618 // Type or member is obsolete
MyNameObjectCollection coll = new MyNameObjectCollection(CaseInsensitiveHashCodeProvider.Default, CaseInsensitiveComparer.Default);
#pragma warning restore CS0618 // Type or member is obsolete
coll.Add(null, null);
Assert.Equal(1, coll.Count);
coll.Remove(null);
Assert.Equal(0, coll.Count);
}
public void SyncRoot()
{
ICollection nameObjectCollection1 = new MyNameObjectCollection();
ICollection nameObjectCollection2 = new MyNameObjectCollection();
Assert.False(nameObjectCollection1.IsSynchronized);
Assert.Same(nameObjectCollection1.SyncRoot, nameObjectCollection1.SyncRoot);
Assert.NotSame(nameObjectCollection1.SyncRoot, nameObjectCollection2.SyncRoot);
}
public void SyncRoot()
{
ICollection nameObjectCollection1 = new MyNameObjectCollection();
ICollection nameObjectCollection2 = new MyNameObjectCollection();
Assert.False(nameObjectCollection1.IsSynchronized);
Assert.Same(nameObjectCollection1.SyncRoot, nameObjectCollection1.SyncRoot);
Assert.NotEqual(nameObjectCollection1.SyncRoot, nameObjectCollection2.SyncRoot);
}
public void GetAllValues(int count, Type type)
{
MyNameObjectCollection nameObjectCollection = Helpers.CreateNameObjectCollection(count);
if (type == typeof(object))
{
VerifyGetAllValues(nameObjectCollection, nameObjectCollection.GetAllValues());
}
VerifyGetAllValues(nameObjectCollection, nameObjectCollection.GetAllValues(type));
}
public void Constructor_Provider_Comparer()
{
#pragma warning disable CS0618 // Type or member is obsolete
MyNameObjectCollection coll = new MyNameObjectCollection(CaseInsensitiveHashCodeProvider.Default, CaseInsensitiveComparer.Default);
#pragma warning restore CS0618 // Type or member is obsolete
coll.Add(null, null);
Assert.Equal(1, coll.Count);
coll.Remove(null);
Assert.Equal(0, coll.Count);
}
public void Keys_CopyTo_NullKeys()
{
MyNameObjectCollection nameObjectCollection = new MyNameObjectCollection();
nameObjectCollection.Add(null, new Foo("1"));
nameObjectCollection.Add(null, new Foo("2"));
nameObjectCollection.Add(null, null);
nameObjectCollection.Add(null, new Foo("3"));
Keys_CopyTo_Helper(nameObjectCollection, 0);
}
public void RemoveAt()
{
MyNameObjectCollection nameObjectCollection = Helpers.CreateNameObjectCollection(10);
nameObjectCollection.Add(null, new Foo("null-value"));
nameObjectCollection.Add(null, null);
nameObjectCollection.Add("repeated-name", null);
nameObjectCollection.Add("repeated-name", new Foo("repeated-name-value"));
// Remove from the middle
nameObjectCollection.RemoveAt(3);
Assert.Equal(13, nameObjectCollection.Count);
Assert.Null(nameObjectCollection["Name_3"]);
Assert.Equal("Name_4", nameObjectCollection.GetKey(3));
// Remove the first
nameObjectCollection.RemoveAt(0);
Assert.Equal(12, nameObjectCollection.Count);
Assert.Null(nameObjectCollection["Name_0"]);
Assert.Equal("Name_1", nameObjectCollection.GetKey(0));
// Remove the last
nameObjectCollection.RemoveAt(nameObjectCollection.Count - 1);
Assert.Equal(11, nameObjectCollection.Count);
Assert.Equal("repeated-name", nameObjectCollection.GetKey(nameObjectCollection.Count - 1));
Assert.Null(nameObjectCollection["repeated-name"]);
// Remove all
int count = nameObjectCollection.Count;
for (int i = 0; i < count; i++)
{
int newCount = 11 - i - 1;
string key = nameObjectCollection.GetKey(0);
string nextKey = null;
if (newCount != 0)
{
nextKey = nameObjectCollection.GetKey(1);
}
nameObjectCollection.RemoveAt(0);
Assert.Equal(newCount, nameObjectCollection.Count);
Assert.Null(nameObjectCollection[key]);
if (newCount != 0)
{
Assert.Equal(nextKey, nameObjectCollection.GetKey(0));
}
}
}
public void Set_ObjectAtIndex_ModifiesCollection()
{
var noc = new MyNameObjectCollection();
for (int i = 0; i < 10; i++)
{
var foo1 = new Foo();
noc.Add("Name_" + i, foo1);
var foo2 = new Foo();
noc[i] = foo2;
Assert.Equal(foo2, noc[i]);
}
}
public void Set_ObjectAtIndex_ModifiesCollection()
{
var noc = new MyNameObjectCollection();
for (int i = 0; i < 10; i++)
{
var foo1 = new Foo("Value_1");
noc.Add("Name_" + i, foo1);
var foo2 = new Foo("Value_2");
noc[i] = foo2;
Assert.Same(foo2, noc[i]);
}
}
public void Constructor_Int_Provider_Comparer()
{
#pragma warning disable CS0618 // Type or member is obsolete
MyNameObjectCollection coll = new MyNameObjectCollection(5, CaseInsensitiveHashCodeProvider.DefaultInvariant, CaseInsensitiveComparer.DefaultInvariant);
#pragma warning restore CS0618 // Type or member is obsolete
coll.Add("a", new Foo("1"));
int i = 0;
IEnumerator e = coll.GetEnumerator();
while (e.MoveNext())
{
i++;
}
Assert.Equal(1, i);
}
void CheckFooArray(Foo[] array, MyNameObjectCollection expected)
{
if (array.Length != expected.Count)
{
Assert.False(true, string.Format(_strErr + "Array length != {0}. Length == {1}", expected.Count, array.Length));
}
for (int i = 0; i < expected.Count; i++)
{
if ((array[i]) != expected[i])
{
Assert.False(true, string.Format("Value {0} is incorrect. array[{0}]={1}, should be {2}", i, (array[i]), expected[i]));
}
}
}
public void Constructor_Int_Provider_Comparer()
{
#pragma warning disable CS0618 // Type or member is obsolete
MyNameObjectCollection coll = new MyNameObjectCollection(5, CaseInsensitiveHashCodeProvider.DefaultInvariant, CaseInsensitiveComparer.DefaultInvariant);
#pragma warning restore CS0618 // Type or member is obsolete
coll.Add("a", new Foo("1"));
int i = 0;
IEnumerator e = coll.GetEnumerator();
while (e.MoveNext())
{
i++;
}
Assert.Equal(1, i);
}
void CheckFooArray(Foo[] array, MyNameObjectCollection expected)
{
if (array.Length != expected.Count)
{
Assert.False(true, string.Format(_strErr + "Array length != {0}. Length == {1}", expected.Count, array.Length));
}
for (int i = 0; i < expected.Count; i++)
{
if ((array[i]) != expected[i])
{
Assert.False(true, string.Format("Value {0} is incorrect. array[{0}]={1}, should be {2}", i, (array[i]), expected[i]));
}
}
}
public void Test01()
{
MyNameObjectCollection noc;
Object[] objarray;
Foo[] fooarray;
// [] GetAllValues() on empty collection
noc = new MyNameObjectCollection();
objarray = noc.GetAllValues();
CheckObjArray(objarray, noc);
// [] GetAllValues() on non-empty collection
noc = new MyNameObjectCollection();
for (int i = 0; i < 15; i++)
{
noc.Add("str_" + i.ToString(), new Foo());
}
objarray = noc.GetAllValues();
CheckObjArray(objarray, noc);
// [] GetAllValues(Type) on empty collection
_strErr = "Err_003, ";
noc = new MyNameObjectCollection();
fooarray = (Foo[])noc.GetAllValues(typeof(Foo));
CheckFooArray(fooarray, noc);
// [] GetAllValues(Type) on non-empty collection
noc = new MyNameObjectCollection();
for (int i = 0; i < 15; i++)
{
noc.Add("str_" + i.ToString(), new Foo());
}
fooarray = (Foo[])noc.GetAllValues(typeof(Foo));
CheckFooArray(fooarray, noc);
// [] GetAllValues(Type) with incompatible type
noc = new MyNameObjectCollection();
for (int i = 0; i < 15; i++)
{
noc.Add("str_" + i.ToString(), new Foo());
}
Assert.Throws <ArrayTypeMismatchException>(() => { Array array = noc.GetAllValues(typeof(String)); });
}
public void Keys_GetEnumerator_Invalid(int count)
{
MyNameObjectCollection nameObjectCollection = Helpers.CreateNameObjectCollection(count);
NameObjectCollectionBase.KeysCollection keys = nameObjectCollection.Keys;
IEnumerator enumerator = keys.GetEnumerator();
// Has not started enumerating
Assert.Throws <InvalidOperationException>(() => enumerator.Current);
// Has finished enumerating
while (enumerator.MoveNext())
{
;
}
Assert.Throws <InvalidOperationException>(() => enumerator.Current);
// Has reset enumerating
enumerator.Reset();
Assert.Throws <InvalidOperationException>(() => enumerator.Current);
// Modify collection
enumerator.MoveNext();
nameObjectCollection.Add("new-name", new Foo("new-value"));
Assert.Throws <InvalidOperationException>(() => enumerator.MoveNext());
Assert.Throws <InvalidOperationException>(() => enumerator.Reset());
if (count > 0)
{
Assert.NotNull(enumerator.Current);
}
// Modified read only collection still throws
nameObjectCollection.IsReadOnly = true;
Assert.Throws <InvalidOperationException>(() => enumerator.MoveNext());
Assert.Throws <InvalidOperationException>(() => enumerator.Reset());
// Clear collection
nameObjectCollection.IsReadOnly = false;
enumerator = keys.GetEnumerator();
enumerator.MoveNext();
nameObjectCollection.Clear();
Assert.Throws <InvalidOperationException>(() => enumerator.Current);
Assert.Throws <InvalidOperationException>(() => enumerator.MoveNext());
Assert.Throws <InvalidOperationException>(() => enumerator.Reset());
}
public void Test01()
{
MyNameObjectCollection noc;
Object[] objarray;
Foo[] fooarray;
// [] GetAllValues() on empty collection
noc = new MyNameObjectCollection();
objarray = noc.GetAllValues();
CheckObjArray(objarray, noc);
// [] GetAllValues() on non-empty collection
noc = new MyNameObjectCollection();
for (int i = 0; i < 15; i++)
{
noc.Add("str_" + i.ToString(), new Foo());
}
objarray = noc.GetAllValues();
CheckObjArray(objarray, noc);
// [] GetAllValues(Type) on empty collection
_strErr = "Err_003, ";
noc = new MyNameObjectCollection();
fooarray = (Foo[])noc.GetAllValues(typeof(Foo));
CheckFooArray(fooarray, noc);
// [] GetAllValues(Type) on non-empty collection
noc = new MyNameObjectCollection();
for (int i = 0; i < 15; i++)
{
noc.Add("str_" + i.ToString(), new Foo());
}
fooarray = (Foo[])noc.GetAllValues(typeof(Foo));
CheckFooArray(fooarray, noc);
// [] GetAllValues(Type) with incompatible type
noc = new MyNameObjectCollection();
for (int i = 0; i < 15; i++)
{
noc.Add("str_" + i.ToString(), new Foo());
}
Assert.Throws<ArrayTypeMismatchException>(() => { Array array = noc.GetAllValues(typeof(String)); });
}
public void Test01()
{
// [] Get SyncRoot, same instance returns same object
MyNameObjectCollection noc1 = new MyNameObjectCollection();
MyNameObjectCollection noc2;
noc1.Add("key1", new Foo());
noc1.Add("key2", new Foo());
if (((ICollection)noc1).SyncRoot == null)
{
Assert.False(true, _strErr + "SyncRoot object is null");
}
noc2 = noc1;
if (((ICollection)noc1).SyncRoot != ((ICollection)noc2).SyncRoot)
{
Assert.False(true, _strErr + "Different SyncRoot objects for same collection");
}
// [] Different instances return different SyncRoot objects
noc1 = new MyNameObjectCollection();
noc2 = new MyNameObjectCollection();
if (((ICollection)noc1).SyncRoot == ((ICollection)noc2).SyncRoot)
{
Assert.False(true, _strErr + "SyncRoot for 2 different collections is the same");
}
// [] IsSynchronized returns false
noc1 = new MyNameObjectCollection();
if (((ICollection)noc1).IsSynchronized != false)
{
Assert.False(true, _strErr + "IsSynchronized should be false!");
}
// [] SyncRoot is of type Object
noc1 = new MyNameObjectCollection();
if (((ICollection)noc1).SyncRoot.GetType() != typeof(Object))
{
Assert.False(true, _strErr + "SyncRoot is not of type Object");
}
}
public void Test01()
{
// [] Get SyncRoot, same instance returns same object
MyNameObjectCollection noc1 = new MyNameObjectCollection();
MyNameObjectCollection noc2;
noc1.Add("key1", new Foo());
noc1.Add("key2", new Foo());
if (((ICollection)noc1).SyncRoot == null)
{
Assert.False(true, _strErr + "SyncRoot object is null");
}
noc2 = noc1;
if (((ICollection)noc1).SyncRoot != ((ICollection)noc2).SyncRoot)
{
Assert.False(true, _strErr + "Different SyncRoot objects for same collection");
}
// [] Different instances return different SyncRoot objects
noc1 = new MyNameObjectCollection();
noc2 = new MyNameObjectCollection();
if (((ICollection)noc1).SyncRoot == ((ICollection)noc2).SyncRoot)
{
Assert.False(true, _strErr + "SyncRoot for 2 different collections is the same");
}
// [] IsSynchronized returns false
noc1 = new MyNameObjectCollection();
if (((ICollection)noc1).IsSynchronized != false)
{
Assert.False(true, _strErr + "IsSynchronized should be false!");
}
// [] SyncRoot is of type Object
noc1 = new MyNameObjectCollection();
if (((ICollection)noc1).SyncRoot.GetType() != typeof(Object))
{
Assert.False(true, _strErr + "SyncRoot is not of type Object");
}
}
public void CopyTo_Invalid(int count)
{
MyNameObjectCollection nameObjectCollection = Helpers.CreateNameObjectCollection(count);
ICollection collection = nameObjectCollection;
Assert.Throws <ArgumentNullException>("array", () => collection.CopyTo(null, 0));
Assert.Throws <ArgumentException>("array", () => collection.CopyTo(new string[count, count], 0));
if (count > 0)
{
Assert.Throws <ArgumentException>(null, () => collection.CopyTo(new string[0], 0));
Assert.Throws <ArgumentException>(null, () => collection.CopyTo(new string[count - 1], 0));
Assert.Throws <InvalidCastException>(() => collection.CopyTo(new Foo[count], 0));
}
Assert.Throws <ArgumentOutOfRangeException>("index", () => collection.CopyTo(new string[count], -1));
Assert.Throws <ArgumentException>(null, () => collection.CopyTo(new string[count], 1));
Assert.Throws <ArgumentException>(null, () => collection.CopyTo(new string[count], count + 1));
}
public void GetEnumerator(int count)
{
MyNameObjectCollection nameObjectCollection = Helpers.CreateNameObjectCollection(count);
Assert.NotSame(nameObjectCollection.GetEnumerator(), nameObjectCollection.GetEnumerator());
IEnumerator enumerator = nameObjectCollection.GetEnumerator();
for (int i = 0; i < 2; i++)
{
int counter = 0;
while (enumerator.MoveNext())
{
Assert.Equal(nameObjectCollection.GetKey(counter), enumerator.Current);
counter++;
}
Assert.Equal(count, nameObjectCollection.Count);
enumerator.Reset();
}
}
public void IsReadOnly_Set()
{
MyNameObjectCollection nameObjectCollection = Helpers.CreateNameObjectCollection(10);
Assert.False(nameObjectCollection.IsReadOnly);
nameObjectCollection.IsReadOnly = true;
Assert.True(nameObjectCollection.IsReadOnly);
Assert.Throws <NotSupportedException>(() => nameObjectCollection.Add("name", null));
Assert.Throws <NotSupportedException>(() => nameObjectCollection["name"] = null);
Assert.Throws <NotSupportedException>(() => nameObjectCollection[0] = null);
Assert.Throws <NotSupportedException>(() => nameObjectCollection.Remove("name"));
Assert.Throws <NotSupportedException>(() => nameObjectCollection.RemoveAt(0));
Assert.Throws <NotSupportedException>(() => nameObjectCollection.Clear());
Assert.Equal("Name_0", nameObjectCollection.GetKey(0));
Assert.Equal(new Foo("Value_0"), nameObjectCollection["Name_0"]);
Assert.Equal(new Foo("Value_0"), nameObjectCollection[0]);
}
public void Keys_GetEnumerator(int count)
{
MyNameObjectCollection nameObjectCollection = Helpers.CreateNameObjectCollection(count);
NameObjectCollectionBase.KeysCollection keys = nameObjectCollection.Keys;
Assert.NotSame(keys.GetEnumerator(), keys.GetEnumerator());
IEnumerator enumerator = keys.GetEnumerator();
for (int i = 0; i < 2; i++)
{
int counter = 0;
while (enumerator.MoveNext())
{
Assert.Equal(keys[counter], enumerator.Current);
counter++;
}
Assert.Equal(count, keys.Count);
enumerator.Reset();
}
}
public void Test01()
{
MyNameObjectCollection noc = new MyNameObjectCollection();
Array array = null;
ArrayList ArrayValues = new ArrayList();
Random rand = new Random(-55);
int n = 0;
String key1 = "key1";
String key2 = "key2";
Foo val1 = new Foo();
Foo val2 = new Foo();
// [] Copy a collection to middle of target array.
// Set up initial collection
n = rand.Next(10, 1000);
for (int i = 0; i < n; i++)
{
noc.Add("key_" + i.ToString(), new Foo());
}
// Set up initial array
n = noc.Count + rand.Next(20, 100);
array = Array.CreateInstance(typeof(String), n);
ArrayValues.Clear();
for (int i = 0; i < n; i++)
{
String v = "arrayvalue_" + i.ToString();
array.SetValue(v, i);
ArrayValues.Add(v);
}
// Copy the collection
int offset = 10;
((ICollection)noc).CopyTo(array, offset);
for (int i = 0; i < noc.Count; i++)
{
ArrayValues[i + offset] = noc.GetKey(i);
}
// Check array
CheckArray(array, ArrayValues);
// [] Verify copy is distinct from original collection.
// Clear initial collection
noc.Clear();
// Verify copy is not cleared
CheckArray(array, ArrayValues);
// [] Fill whole array (index=0)
// Set up initial collection
noc = new MyNameObjectCollection();
n = rand.Next(10, 1000);
for (int i = 0; i < n; i++)
{
noc.Add("key_" + i.ToString(), new Foo());
}
// Set up initial array
n = noc.Count;
array = Array.CreateInstance(typeof(String), n);
ArrayValues.Clear();
for (int i = 0; i < n; i++)
{
String v = "arrayvalue_" + i.ToString();
array.SetValue(v, i);
ArrayValues.Add(v);
}
// Copy the collection
((ICollection)noc).CopyTo(array, 0);
for (int i = 0; i < noc.Count; i++)
{
ArrayValues[i] = noc.GetKey(i);
}
// Check array
CheckArray(array, ArrayValues);
// [] index = max index in array
// Set up initial collection
noc.Clear();
noc.Add("key1", new Foo());
// Set up initial array
n = noc.Count + rand.Next(1, 100);
array = Array.CreateInstance(typeof(String), n);
ArrayValues.Clear();
for (int i = 0; i < n; i++)
{
String v = "arrayvalue_" + i.ToString();
array.SetValue(v, i);
ArrayValues.Add(v);
}
// Copy the collection
offset = ArrayValues.Count - 1;
((ICollection)noc).CopyTo(array, offset);
ArrayValues[offset] = noc.GetKey(0);
// Retrieve values
CheckArray(array, ArrayValues);
// [] Target array is zero-length.
array = Array.CreateInstance(typeof(String), 0);
noc = new MyNameObjectCollection();
noc.Add(key1, val1);
noc.Add(key2, val2);
Assert.Throws <ArgumentException>(() => { ((ICollection)noc).CopyTo(array, 0); });
// [] Call on an empty collection (to zero-length array).
noc = new MyNameObjectCollection();
array = Array.CreateInstance(typeof(String), 0);
// Copy the collection
((ICollection)noc).CopyTo(array, 0);
// [] Call on an empty collection.
noc = new MyNameObjectCollection();
array = Array.CreateInstance(typeof(String), 16);
// Copy the collection
((ICollection)noc).CopyTo(array, 0);
// Retrieve elements
foreach (String v in array)
{
if (v != null)
{
Assert.False(true, _strErr + "Value is incorrect. array should be null");
}
}
// [] Call with array = null
noc = new MyNameObjectCollection();
Assert.Throws <ArgumentNullException>(() => { ((ICollection)noc).CopyTo(null, 0); });
// [] Target array is multidimensional.
array = new string[20, 2];
noc = new MyNameObjectCollection();
noc.Add(key1, val1);
noc.Add(key2, val2);
Assert.Throws <ArgumentException>(() => { ((ICollection)noc).CopyTo(array, 16); });
// [] Target array is of incompatible type.
array = Array.CreateInstance(typeof(Foo), 10);
noc = new MyNameObjectCollection();
noc.Add(key1, val1);
noc.Add(key2, val2);
Assert.Throws <InvalidCastException>(() => { ((ICollection)noc).CopyTo(array, 1); });
// [] index = array length
n = rand.Next(10, 100);
array = Array.CreateInstance(typeof(String), n);
noc = new MyNameObjectCollection();
noc.Add(key1, val1);
noc.Add(key2, val2);
Assert.Throws <ArgumentException>(() => { ((ICollection)noc).CopyTo(array, n); });
// [] index > array length
n = rand.Next(10, 100);
array = Array.CreateInstance(typeof(String), n);
noc = new MyNameObjectCollection();
noc.Add(key1, val1);
noc.Add(key2, val2);
Assert.Throws <ArgumentException>(() => { ((ICollection)noc).CopyTo(array, n + 1); });
// [] index = Int32.MaxValue
array = Array.CreateInstance(typeof(String), 10);
noc = new MyNameObjectCollection();
noc.Add(key1, val1);
noc.Add(key2, val2);
Assert.Throws <ArgumentException>(() => { ((ICollection)noc).CopyTo(array, Int32.MaxValue); });
// [] index < 0
array = Array.CreateInstance(typeof(String), 10);
noc = new MyNameObjectCollection();
noc.Add(key1, val1);
noc.Add(key2, val2);
Assert.Throws <ArgumentOutOfRangeException>(() => { ((ICollection)noc).CopyTo(array, -1); });
// [] index is valid but collection doesn't fit in available space
noc = new MyNameObjectCollection();
// Set up initial collection
n = rand.Next(10, 1000);
for (int i = 0; i < n; i++)
{
noc.Add("key_" + i.ToString(), new Foo());
}
// Set up initial array
n = noc.Count + 20;
array = Array.CreateInstance(typeof(Foo), n);
Assert.Throws <ArgumentException>(() => { ((ICollection)noc).CopyTo(array, 30); }); // array is only 20 bigger than collection
// [] index is negative
noc = new MyNameObjectCollection();
// Set up initial collection
n = rand.Next(10, 1000);
for (int i = 0; i < n; i++)
{
noc.Add("key_" + i.ToString(), new Foo());
}
// Set up initial array
n = noc.Count + 20;
array = Array.CreateInstance(typeof(Foo), n);
Assert.Throws <ArgumentOutOfRangeException>(() => { ((ICollection)noc).CopyTo(array, -1); });
}
public void Test01()
{
MyNameObjectCollection noc = new MyNameObjectCollection();
String key = "key1";
Foo value = new Foo();
// [] IsReadOnly is initially false
if (noc.IsReadOnly != false)
{
Assert.False(true, _strErr + "IsReadOnly should be false initially");
}
// [] Set IsReadOnly to true
noc.IsReadOnly = true;
if (noc.IsReadOnly != true)
{
Assert.False(true, _strErr + "IsReadOnly should be true");
}
// Now we are going to verify that methods that change the collection throw an exception
// if IsReadOnly is true.
// [] Set IsReadOnly to false and add an element
noc.IsReadOnly = false;
if (noc.IsReadOnly != false)
{
Assert.False(true, _strErr + "IsReadOnly should be false");
}
noc.Add(key, value);
noc.IsReadOnly = true;
// [] Add fails
Assert.Throws<NotSupportedException>(() => { noc.Add("new key", new Foo()); });
// [] Remove fails
Assert.Throws<NotSupportedException>(() => { noc.Remove(key); });
// [] RemoveAt fails
Assert.Throws<NotSupportedException>(() => { noc.RemoveAt(0); });
// [] Clear fails
Assert.Throws<NotSupportedException>(() => { noc.Clear(); });
// [] Get by key succeeds
if (noc[key] != value)
{
Assert.False(true, string.Format(_strErr + "Wrong value returned. Expected {0}, got {1}", value, noc[key]));
}
// [] Set by key fails
Assert.Throws<NotSupportedException>(() => { noc[key] = new Foo(); });
// [] Get by index succeeds
if (noc[0] != value)
{
Assert.False(true, string.Format(_strErr + "Wrong value returned. Expected {0}, got {1}", value, noc[0]));
}
// [] Set by index fails
Assert.Throws<NotSupportedException>(() => { noc[0] = new Foo(); });
// [] GetKey succeeds
if (noc.GetKey(0) != key)
{
Assert.False(true, string.Format(_strErr + "Wrong value returned. Expected {0}, got {1}", key, noc.GetKey(0)));
}
}
public void Test01()
{
MyNameObjectCollection noc = new MyNameObjectCollection();
String key = "key1";
Foo value = new Foo();
// [] IsReadOnly is initially false
if (noc.IsReadOnly != false)
{
Assert.False(true, _strErr + "IsReadOnly should be false initially");
}
// [] Set IsReadOnly to true
noc.IsReadOnly = true;
if (noc.IsReadOnly != true)
{
Assert.False(true, _strErr + "IsReadOnly should be true");
}
// Now we are going to verify that methods that change the collection throw an exception
// if IsReadOnly is true.
// [] Set IsReadOnly to false and add an element
noc.IsReadOnly = false;
if (noc.IsReadOnly != false)
{
Assert.False(true, _strErr + "IsReadOnly should be false");
}
noc.Add(key, value);
noc.IsReadOnly = true;
// [] Add fails
Assert.Throws <NotSupportedException>(() => { noc.Add("new key", new Foo()); });
// [] Remove fails
Assert.Throws <NotSupportedException>(() => { noc.Remove(key); });
// [] RemoveAt fails
Assert.Throws <NotSupportedException>(() => { noc.RemoveAt(0); });
// [] Clear fails
Assert.Throws <NotSupportedException>(() => { noc.Clear(); });
// [] Get by key succeeds
if (noc[key] != value)
{
Assert.False(true, string.Format(_strErr + "Wrong value returned. Expected {0}, got {1}", value, noc[key]));
}
// [] Set by key fails
Assert.Throws <NotSupportedException>(() => { noc[key] = new Foo(); });
// [] Get by index succeeds
if (noc[0] != value)
{
Assert.False(true, string.Format(_strErr + "Wrong value returned. Expected {0}, got {1}", value, noc[0]));
}
// [] Set by index fails
Assert.Throws <NotSupportedException>(() => { noc[0] = new Foo(); });
// [] GetKey succeeds
if (noc.GetKey(0) != key)
{
Assert.False(true, string.Format(_strErr + "Wrong value returned. Expected {0}, got {1}", key, noc.GetKey(0)));
}
}
public void Test01()
{
MyNameObjectCollection noc = new MyNameObjectCollection();
Array array = null;
ArrayList ArrayValues = new ArrayList();
Random rand = new Random(-55);
int n = 0;
String key1 = "key1";
String key2 = "key2";
Foo val1 = new Foo();
Foo val2 = new Foo();
// [] Copy a collection to middle of target array.
// Set up initial collection
n = rand.Next(10, 1000);
for (int i = 0; i < n; i++)
{
noc.Add("key_" + i.ToString(), new Foo());
}
// Set up initial array
n = noc.Count + rand.Next(20, 100);
array = Array.CreateInstance(typeof(String), n);
ArrayValues.Clear();
for (int i = 0; i < n; i++)
{
String v = "arrayvalue_" + i.ToString();
array.SetValue(v, i);
ArrayValues.Add(v);
}
// Copy the collection
int offset = 10;
((ICollection)noc.Keys).CopyTo(array, offset);
for (int i = 0; i < noc.Count; i++)
{
ArrayValues[i + offset] = noc.GetKey(i);
}
// Check array
CheckArray(array, ArrayValues);
// [] Verify copy is distinct from original collection.
// Clear initial collection
noc.Clear();
// Verify copy is not cleared
CheckArray(array, ArrayValues);
// [] Fill whole array (index=0)
// Set up initial collection
noc = new MyNameObjectCollection();
n = rand.Next(10, 1000);
for (int i = 0; i < n; i++)
{
noc.Add("key_" + i.ToString(), new Foo());
}
// Set up initial array
n = noc.Count;
array = Array.CreateInstance(typeof(String), n);
ArrayValues.Clear();
for (int i = 0; i < n; i++)
{
String v = "arrayvalue_" + i.ToString();
array.SetValue(v, i);
ArrayValues.Add(v);
}
// Copy the collection
((ICollection)noc.Keys).CopyTo(array, 0);
for (int i = 0; i < noc.Count; i++)
{
ArrayValues[i] = noc.GetKey(i);
}
// Check array
CheckArray(array, ArrayValues);
// [] index = max index in array
// Set up initial collection
noc.Clear();
noc.Add("key1", new Foo());
// Set up initial array
n = noc.Count + rand.Next(1, 100);
array = Array.CreateInstance(typeof(String), n);
ArrayValues.Clear();
for (int i = 0; i < n; i++)
{
String v = "arrayvalue_" + i.ToString();
array.SetValue(v, i);
ArrayValues.Add(v);
}
// Copy the collection
offset = ArrayValues.Count - 1;
((ICollection)noc.Keys).CopyTo(array, offset);
ArrayValues[offset] = noc.GetKey(0);
// Retrieve values
CheckArray(array, ArrayValues);
// [] Target array is zero-length.
array = Array.CreateInstance(typeof(String), 0);
noc = new MyNameObjectCollection();
noc.Add(key1, val1);
noc.Add(key2, val2);
Assert.Throws<ArgumentException>(() => { ((ICollection)noc.Keys).CopyTo(array, 0); });
// [] Call on an empty collection (to zero-length array).
noc = new MyNameObjectCollection();
array = Array.CreateInstance(typeof(String), 0);
// Copy the collection
((ICollection)noc.Keys).CopyTo(array, 0);
// [] Call on an empty collection.
noc = new MyNameObjectCollection();
array = Array.CreateInstance(typeof(String), 16);
// Copy the collection
((ICollection)noc.Keys).CopyTo(array, 0);
// Retrieve elements
foreach (String v in array)
{
if (v != null)
{
Assert.False(true, _strErr + "Value is incorrect. array should be null");
}
}
// [] Call with array = null
noc = new MyNameObjectCollection();
Assert.Throws<ArgumentNullException>(() => { ((ICollection)noc.Keys).CopyTo(null, 0); });
// [] Target array is multidimensional.
array = new string[20, 2];
noc = new MyNameObjectCollection();
noc.Add(key1, val1);
noc.Add(key2, val2);
Assert.Throws<ArgumentException>(() => { ((ICollection)noc.Keys).CopyTo(array, 16); });
// [] Target array is of incompatible type.
array = Array.CreateInstance(typeof(Foo), 10);
noc = new MyNameObjectCollection();
noc.Add(key1, val1);
noc.Add(key2, val2);
Assert.Throws<InvalidCastException>(() => { ((ICollection)noc.Keys).CopyTo(array, 1); });
// [] index = array length
n = rand.Next(10, 100);
array = Array.CreateInstance(typeof(String), n);
noc = new MyNameObjectCollection();
noc.Add(key1, val1);
noc.Add(key2, val2);
Assert.Throws<ArgumentException>(() => { ((ICollection)noc.Keys).CopyTo(array, n); });
// [] index > array length
n = rand.Next(10, 100);
array = Array.CreateInstance(typeof(String), n);
noc = new MyNameObjectCollection();
noc.Add(key1, val1);
noc.Add(key2, val2);
Assert.Throws<ArgumentException>(() => { ((ICollection)noc.Keys).CopyTo(array, n + 1); });
// [] index = Int32.MaxValue
array = Array.CreateInstance(typeof(String), 10);
noc = new MyNameObjectCollection();
noc.Add(key1, val1);
noc.Add(key2, val2);
Assert.Throws<ArgumentException>(() => { ((ICollection)noc.Keys).CopyTo(array, Int32.MaxValue); });
// [] index < 0
array = Array.CreateInstance(typeof(String), 10);
noc = new MyNameObjectCollection();
noc.Add(key1, val1);
noc.Add(key2, val2);
Assert.Throws<ArgumentOutOfRangeException>(() => { ((ICollection)noc.Keys).CopyTo(array, -1); });
// [] index is valid but collection doesn't fit in available space
noc = new MyNameObjectCollection();
// Set up initial collection
n = rand.Next(10, 1000);
for (int i = 0; i < n; i++)
{
noc.Add("key_" + i.ToString(), new Foo());
}
// Set up initial array
n = noc.Count + 20;
array = Array.CreateInstance(typeof(Foo), n);
Assert.Throws<ArgumentException>(() => { ((ICollection)noc.Keys).CopyTo(array, 30); }); // array is only 20 bigger than collection
// [] index is negative
noc = new MyNameObjectCollection();
// Set up initial collection
n = rand.Next(10, 1000);
for (int i = 0; i < n; i++)
{
noc.Add("key_" + i.ToString(), new Foo());
}
// Set up initial array
n = noc.Count + 20;
array = Array.CreateInstance(typeof(Foo), n);
Assert.Throws<ArgumentOutOfRangeException>(() => { ((ICollection)noc.Keys).CopyTo(array, -1); });
// [] All keys are null
noc = new MyNameObjectCollection();
noc.Add(null, new Foo());
noc.Add(null, new Foo());
noc.Add(null, null);
noc.Add(null, new Foo());
if (noc.Count != 4)
{
Assert.False(true, _strErr + "Elements were not added correctly");
}
array = Array.CreateInstance(typeof(String), 16);
// Copy the collection
((ICollection)noc.Keys).CopyTo(array, 0);
// Retrieve elements
foreach (String v in array)
{
if (v != null)
{
Assert.False(true, _strErr + "Value is incorrect. array should be null");
}
}
}
public void Keys_PreservesInstance(int count)
{
MyNameObjectCollection nameObjectCollection = Helpers.CreateNameObjectCollection(count);
Assert.Same(nameObjectCollection.Keys, nameObjectCollection.Keys);
}
public void Keys_CopyTo_NullKeys()
{
MyNameObjectCollection nameObjectCollection = new MyNameObjectCollection();
nameObjectCollection.Add(null, new Foo("1"));
nameObjectCollection.Add(null, new Foo("2"));
nameObjectCollection.Add(null, null);
nameObjectCollection.Add(null, new Foo("3"));
Keys_CopyTo(nameObjectCollection, 0);
}
public void Test01()
{
MyNameObjectCollection noc = new MyNameObjectCollection();
IEnumerator en = null;
bool res;
// [] Enumerator for empty collection
// Get enumerator
en = noc.GetEnumerator();
// MoveNext should return false
res = en.MoveNext();
if (res)
{
Assert.False(true, _strErr + "MoveNext returned true");
}
// Attempt to get Current should result in exception
Assert.Throws<InvalidOperationException>(() => { String curr = (String)en.Current; });
// [] Enumerator for non-empty collection
// Add items
for (int i = 0; i < 10; i++)
{
noc.Add("key_" + i.ToString(), new Foo());
}
// Get enumerator
en = noc.GetEnumerator();
// Attempt to get Current should result in exception
Assert.Throws<InvalidOperationException>(() => { String curr = (String)en.Current; });
// Iterate over collection
for (int i = 0; i < noc.Count; i++)
{
// MoveNext should return true
res = en.MoveNext();
if (!res)
{
Assert.False(true, string.Format(_strErr + "#{0}, MoveNext returned false", i));
}
// Check current
String curr = (String)en.Current;
if (noc[curr] == null)
{
Assert.False(true, string.Format(_strErr + "#{0}, Current={1}, key not found in collection", i, curr));
}
// Check current again
String current1 = (String)en.Current;
if (current1 != curr)
{
Assert.False(true, string.Format(_strErr + "#{0}, Value of Current changed! Was {1}, now {2}", i, curr, current1));
}
}
// next MoveNext should bring us outside of the collection, return false
res = en.MoveNext();
if (res)
{
Assert.False(true, _strErr + "MoveNext returned true");
}
// Attempt to get Current should result in exception
Assert.Throws<InvalidOperationException>(() => { String curr = (String)en.Current; });
// Reset
en.Reset();
// Attempt to get Current should result in exception
Assert.Throws<InvalidOperationException>(() => { String curr = (String)en.Current; });
// Modify collection and then try MoveNext, Current, Reset
// new collection
noc = new MyNameObjectCollection();
noc.Add("key1", new Foo());
noc.Add("key2", new Foo());
noc.Add("key3", new Foo());
en = noc.GetEnumerator();
// MoveNext
if (!en.MoveNext())
{
Assert.False(true, _strErr + "MoveNext returned false");
}
// Current
String current = (String)en.Current;
// Modify collection
noc.RemoveAt(0);
if (noc.Count != 2)
{
Assert.False(true, string.Format(_strErr + "Collection Count wrong. Expected {0}, got {1}", 2, noc.Count));
}
// Current should not throw, but no guarantee is made on the return value
string curr1 = (String)en.Current;
// MoveNext should throw exception
Assert.Throws<InvalidOperationException>(() => { en.MoveNext(); });
// Reset should throw exception
Assert.Throws<InvalidOperationException>(() => { en.Reset(); });
// Current should not throw, but no guarantee is made on the return value
curr1 = (String)en.Current;
// MoveNext should still throw exception if collection is ReadOnly
noc.IsReadOnly = true;
Assert.Throws<InvalidOperationException>(() => { en.MoveNext(); });
// Clear collection and then try MoveNext, Current, Reset
// new collection
noc = new MyNameObjectCollection();
noc.Add("key1", new Foo());
noc.Add("key2", new Foo());
noc.Add("key3", new Foo());
en = noc.GetEnumerator();
// MoveNext
if (!en.MoveNext())
{
Assert.False(true, _strErr + "MoveNext returned false");
}
// Current
current = (String)en.Current;
// Modify collection
noc.Clear();
if (noc.Count != 0)
{
Assert.False(true, string.Format(_strErr + "Collection Count wrong. Expected {0}, got {1}", 2, noc.Count));
}
// Current throws. Should it throw here?!
Assert.Throws<InvalidOperationException>(() => { String curr = (String)en.Current; });
// MoveNext should throw exception
Assert.Throws<InvalidOperationException>(() => { en.MoveNext(); });
// Reset should throw exception
Assert.Throws<InvalidOperationException>(() => { en.Reset(); });
}
public void Test01()
{
MyNameObjectCollection noc = new MyNameObjectCollection();
ArrayList keys = new ArrayList();
ArrayList values = new ArrayList();
// [] Set up collection, including some null keys and values
for (int i = 0; i < 10; i++)
{
String k = "key_" + i.ToString();
Foo v = new Foo();
noc.Add(k, v);
keys.Add(k);
values.Add(v);
}
Foo val = new Foo();
noc.Add(null, val);
keys.Add(null);
values.Add(val);
noc.Add(null, null);
keys.Add(null);
values.Add(null);
noc.Add("repeatedkey", null);
keys.Add("repeatedkey");
values.Add(null);
noc.Add("repeatedkey", val);
keys.Add("repeatedkey");
values.Add(val);
CheckCollection(noc, keys, values);
// [] Remove from middle of collection
noc.RemoveAt(3);
keys.RemoveAt(3);
values.RemoveAt(3);
CheckCollection(noc, keys, values);
// [] Remove first element
noc.RemoveAt(0);
keys.RemoveAt(0);
values.RemoveAt(0);
CheckCollection(noc, keys, values);
// [] Remove last element
noc.RemoveAt(noc.Count - 1);
keys.RemoveAt(keys.Count - 1);
values.RemoveAt(values.Count - 1);
CheckCollection(noc, keys, values);
// [] Index < 0
Assert.Throws<ArgumentOutOfRangeException>(() => { noc.RemoveAt(-1); });
// [] Index = Count
Assert.Throws<ArgumentOutOfRangeException>(() => { noc.RemoveAt(noc.Count); });
// [] Remove all elements
int n = noc.Count;
for (int i = 0; i < n; i++)
{
noc.RemoveAt(0);
keys.RemoveAt(0);
values.RemoveAt(0);
CheckCollection(noc, keys, values);
}
// [] RemoveAt on an empty collection
Assert.Throws<ArgumentOutOfRangeException>(() => { noc.RemoveAt(0); });
// [] RemoveAt on a ReadOnly collection
noc.Add("key", new Foo());
noc.IsReadOnly = true;
Assert.Throws<NotSupportedException>(() => { noc.RemoveAt(0); });
}
public static void TestGetAllValues_NullType_Throws()
{
var nameObjectCollection = new MyNameObjectCollection();
Assert.Throws <ArgumentNullException>("type", () => nameObjectCollection.GetAllValues(null));
}
public void Test01()
{
MyNameObjectCollection noc = new MyNameObjectCollection();
ArrayList keys = new ArrayList();
ArrayList values = new ArrayList();
// [] Set up collection, including some null keys and values
for (int i = 0; i < 10; i++)
{
String k = "key_" + i.ToString();
Foo v = new Foo();
noc.Add(k, v);
keys.Add(k);
values.Add(v);
}
Foo val = new Foo();
noc.Add(null, val);
keys.Add(null);
values.Add(val);
noc.Add(null, null);
keys.Add(null);
values.Add(null);
noc.Add("repeatedkey", null);
keys.Add("repeatedkey");
values.Add(null);
noc.Add("repeatedkey", val);
keys.Add("repeatedkey");
values.Add(val);
CheckCollection(noc, keys, values);
// [] Remove from middle of collection
noc.RemoveAt(3);
keys.RemoveAt(3);
values.RemoveAt(3);
CheckCollection(noc, keys, values);
// [] Remove first element
noc.RemoveAt(0);
keys.RemoveAt(0);
values.RemoveAt(0);
CheckCollection(noc, keys, values);
// [] Remove last element
noc.RemoveAt(noc.Count - 1);
keys.RemoveAt(keys.Count - 1);
values.RemoveAt(values.Count - 1);
CheckCollection(noc, keys, values);
// [] Index < 0
Assert.Throws <ArgumentOutOfRangeException>(() => { noc.RemoveAt(-1); });
// [] Index = Count
Assert.Throws <ArgumentOutOfRangeException>(() => { noc.RemoveAt(noc.Count); });
// [] Remove all elements
int n = noc.Count;
for (int i = 0; i < n; i++)
{
noc.RemoveAt(0);
keys.RemoveAt(0);
values.RemoveAt(0);
CheckCollection(noc, keys, values);
}
// [] RemoveAt on an empty collection
Assert.Throws <ArgumentOutOfRangeException>(() => { noc.RemoveAt(0); });
// [] RemoveAt on a ReadOnly collection
noc.Add("key", new Foo());
noc.IsReadOnly = true;
Assert.Throws <NotSupportedException>(() => { noc.RemoveAt(0); });
}
void CheckCollection(MyNameObjectCollection noc, ArrayList keys, ArrayList values)
{
// Check counts
if ((noc.Count != keys.Count) || (noc.Count != values.Count))
{
Assert.False(true, _strErr + "Wrong number of elements, or mismatched keys and values.");
Assert.False(true, string.Format(_strErr + "noc.Count={0}, keys.Count={1}, values.Count={2}", noc.Count, keys.Count, values.Count));
}
// Check keys/values
for (int i = 0; i < noc.Count; i++)
{
// keys
if (noc.GetKey(i) != (String)keys[i])
{
Assert.False(true, string.Format(_strErr + "key #{0} not as expected. noc.GetKey({0}) = {1}, should be {2}", i, noc.GetKey(i), keys[i]));
}
// values
if (values[i] == null)
{
if (noc[i] != null)
{
Assert.False(true, string.Format(_strErr + "value #{0} not as expected. noc[{0}] = {1}, should be {2}", i, noc[i], values[i]));
}
}
else
{
if ((noc[i] == null) || ((Foo)noc[i] != (Foo)values[i]))
{
Assert.False(true, string.Format(_strErr + "value #{0} not as expected. noc[{0}] = {1}, should be {2}", i, noc[i], values[i]));
}
}
}
}
public void Keys_CopyTo(int count, int index)
{
MyNameObjectCollection nameObjectCollection = Helpers.CreateNameObjectCollection(count);
Keys_CopyTo_Helper(nameObjectCollection, index);
}
public void Test01()
{
MyNameObjectCollection noc = new MyNameObjectCollection();
NameObjectCollectionBase.KeysCollection keys;
// Set up initial collection
for (int i = 0; i < 20; i++)
{
noc.Add("key_" + i.ToString(), new Foo());
}
// Get the KeysCollection
_strErr = "Err_001, ";
keys = noc.Keys;
// Check Count
if (keys.Count != noc.Count)
{
Assert.False(true, string.Format(_strErr + "keys.Count is wrong. expected {0}, got {1}", noc.Count, keys.Count));
}
// Compare - test Get, Item
for (int i = 0; i < noc.Count; i++)
{
if (keys.Get(i) != "key_" + i.ToString())
{
Assert.False(true, string.Format(_strErr + "keys.Get({0}) is wrong. expected {1}, got {2}", i, "key_" + i.ToString(), keys.Get(i)));
}
if (keys[i] != "key_" + i.ToString())
{
Assert.False(true, string.Format(_strErr + "keys[{0}] is wrong. expected {1}, got {2}", i, "key_" + i.ToString(), keys[i]));
}
}
// Get enumerator - it's the same enumerator as the original collection, so don't
// need to test it again here.
IEnumerator en = keys.GetEnumerator();
// Get SyncRoot - just a cursory test
if (((ICollection)keys).SyncRoot != ((ICollection)noc).SyncRoot)
{
Assert.False(true, _strErr + "keys.SyncRoot was not the same as noc.SyncRoot");
}
// Get IsSynchronized
if (((ICollection)keys).IsSynchronized)
{
Assert.False(true, _strErr + "keys.SyncRoot was not the same as noc.SyncRoot");
}
// Check empty collection
noc = new MyNameObjectCollection();
keys = noc.Keys;
// Check Count
if (keys.Count != 0)
{
Assert.False(true, string.Format(_strErr + "keys.Count is wrong. expected {0}, got {1}", 0, keys.Count));
}
}
public void Keys_CopyTo(MyNameObjectCollection nameObjectCollection, int index)
{
ICollection keys = nameObjectCollection.Keys;
string[] keysArray = new string[index + keys.Count + index];
keys.CopyTo(keysArray, index);
for (int i = 0; i < index; i++)
{
Assert.Null(keysArray[i]);
}
for (int i = 0; i < keys.Count; i++)
{
Assert.Equal(nameObjectCollection.GetKey(i), keysArray[i + index]);
}
for (int i = index + keys.Count; i < keysArray.Length; i++)
{
Assert.Null(keysArray[i]);
}
// Clearing the nameObjectCollection should not affect the keys copy
int previousCount = keysArray.Length;
nameObjectCollection.Clear();
Assert.Equal(previousCount, keysArray.Length);
}
public static void TestGetAllValues_NullType_Throws()
{
var nameObjectCollection = new MyNameObjectCollection();
Assert.Throws<ArgumentNullException>("type", () => nameObjectCollection.GetAllValues(null));
}
public void Test01()
{
MyNameObjectCollection noc = new MyNameObjectCollection();
IEnumerator en = null;
bool res;
// [] Enumerator for empty collection
// Get enumerator
en = noc.GetEnumerator();
// MoveNext should return false
res = en.MoveNext();
if (res)
{
Assert.False(true, _strErr + "MoveNext returned true");
}
// Attempt to get Current should result in exception
Assert.Throws <InvalidOperationException>(() => { String curr = (String)en.Current; });
// [] Enumerator for non-empty collection
// Add items
for (int i = 0; i < 10; i++)
{
noc.Add("key_" + i.ToString(), new Foo());
}
// Get enumerator
en = noc.GetEnumerator();
// Attempt to get Current should result in exception
Assert.Throws <InvalidOperationException>(() => { String curr = (String)en.Current; });
// Iterate over collection
for (int i = 0; i < noc.Count; i++)
{
// MoveNext should return true
res = en.MoveNext();
if (!res)
{
Assert.False(true, string.Format(_strErr + "#{0}, MoveNext returned false", i));
}
// Check current
String curr = (String)en.Current;
if (noc[curr] == null)
{
Assert.False(true, string.Format(_strErr + "#{0}, Current={1}, key not found in collection", i, curr));
}
// Check current again
String current1 = (String)en.Current;
if (current1 != curr)
{
Assert.False(true, string.Format(_strErr + "#{0}, Value of Current changed! Was {1}, now {2}", i, curr, current1));
}
}
// next MoveNext should bring us outside of the collection, return false
res = en.MoveNext();
if (res)
{
Assert.False(true, _strErr + "MoveNext returned true");
}
// Attempt to get Current should result in exception
Assert.Throws <InvalidOperationException>(() => { String curr = (String)en.Current; });
// Reset
en.Reset();
// Attempt to get Current should result in exception
Assert.Throws <InvalidOperationException>(() => { String curr = (String)en.Current; });
// Modify collection and then try MoveNext, Current, Reset
// new collection
noc = new MyNameObjectCollection();
noc.Add("key1", new Foo());
noc.Add("key2", new Foo());
noc.Add("key3", new Foo());
en = noc.GetEnumerator();
// MoveNext
if (!en.MoveNext())
{
Assert.False(true, _strErr + "MoveNext returned false");
}
// Current
String current = (String)en.Current;
// Modify collection
noc.RemoveAt(0);
if (noc.Count != 2)
{
Assert.False(true, string.Format(_strErr + "Collection Count wrong. Expected {0}, got {1}", 2, noc.Count));
}
// Current should not throw, but no guarantee is made on the return value
string curr1 = (String)en.Current;
// MoveNext should throw exception
Assert.Throws <InvalidOperationException>(() => { en.MoveNext(); });
// Reset should throw exception
Assert.Throws <InvalidOperationException>(() => { en.Reset(); });
// Current should not throw, but no guarantee is made on the return value
curr1 = (String)en.Current;
// MoveNext should still throw exception if collection is ReadOnly
noc.IsReadOnly = true;
Assert.Throws <InvalidOperationException>(() => { en.MoveNext(); });
// Clear collection and then try MoveNext, Current, Reset
// new collection
noc = new MyNameObjectCollection();
noc.Add("key1", new Foo());
noc.Add("key2", new Foo());
noc.Add("key3", new Foo());
en = noc.GetEnumerator();
// MoveNext
if (!en.MoveNext())
{
Assert.False(true, _strErr + "MoveNext returned false");
}
// Current
current = (String)en.Current;
// Modify collection
noc.Clear();
if (noc.Count != 0)
{
Assert.False(true, string.Format(_strErr + "Collection Count wrong. Expected {0}, got {1}", 2, noc.Count));
}
// Current throws. Should it throw here?!
Assert.Throws <InvalidOperationException>(() => { String curr = (String)en.Current; });
// MoveNext should throw exception
Assert.Throws <InvalidOperationException>(() => { en.MoveNext(); });
// Reset should throw exception
Assert.Throws <InvalidOperationException>(() => { en.Reset(); });
}
