using System;

using System.Collections;

using System.Collections.Generic;

using NUnit.Framework;



namespace Delta.Utilities.Collections

{

	/// <summary>

	/// Keyed list, the generic version.

	/// </summary>

	/// <typeparam name="K">Key type</typeparam>

	/// <typeparam name="V">Value type</typeparam>

	public class KeyedList<K, V>

		: IDictionary<K, V>, IList<KeyValuePair<K, V>>

	{

		#region IsReadOnly (Public)

		/// <summary>

		/// Returns false.

		/// </summary>

		/// <typeparam name="K">K</typeparam>

		/// <typeparam name="V">V</typeparam>

		public bool IsReadOnly

		{

			get

			{

				return false;

			} // get

		}

		#endregion



		#region Count (Public)

		/// <summary>

		/// Returns the number of entries in the KeyedList.

		/// </summary>

		/// <typeparam name="K">K</typeparam>

		/// <typeparam name="V">V</typeparam>

		public int Count

		{

			get

			{

				return objectList.Count;

			} // get

		}

		#endregion



		#region Keys (Public)

		/// <summary>

		/// Get an unordered list of keys.

		/// This collection refers back to the keys in the original Dictionary.

		/// </summary>

		/// <typeparam name="K">K</typeparam>

		/// <typeparam name="V">V</typeparam>

		public ICollection<K> Keys

		{

			get

			{

				return objectTable.Keys;

			} // get

		}

		#endregion



		#region Values (Public)

		/// <summary>

		/// Get an unordered list of values.

		/// This collection refers back to the values in the original Dictionary.

		/// </summary>

		/// <typeparam name="K">K</typeparam>

		/// <typeparam name="V">V</typeparam>

		public ICollection<V> Values

		{

			get

			{

				return objectTable.Values;

			} // get

		}

		#endregion



		#region OrderedKeys (Public)

		/// <summary>

		/// Get the ordered list of keys.

		/// This is a copy of the keys in the original Dictionary.

		/// </summary>

		/// <typeparam name="K">K</typeparam>

		/// <typeparam name="V">V</typeparam>

		public List<K> OrderedKeys

		{

			get

			{

				List<K> retList = new List<K>();



				foreach (KeyValuePair<K, V> kvp in objectList)

				{

					retList.Add(kvp.Key);

				}



				return retList;

			}

		}

		#endregion



		#region OrderedValues (Public)

		/// <summary>

		/// Get the ordered list of values.

		/// This is a copy of the values in the original Dictionary.

		/// </summary>

		/// <typeparam name="K">K</typeparam>

		/// <typeparam name="V">V</typeparam>

		public List<V> OrderedValues

		{

			get

			{

				List<V> retList = new List<V>();



				foreach (KeyValuePair<K, V> kvp in objectList)

				{

					retList.Add(kvp.Value);

				}



				return retList;

			}

		}

		#endregion



		#region Item (Public)

		/// <summary>

		/// Get/Set the value at the specified index.

		/// </summary>

		/// <param name="idx">The index.</param>

		/// <returns>The value.</returns>

		public KeyValuePair<K, V> this[int idx]

		{

			get

			{

				if (idx < 0 ||

				    idx >= Count)

				{

					throw new ArgumentOutOfRangeException("index");

				}



				return objectList[idx];

			}

			set

			{

				if (idx < 0 ||

				    idx >= Count)

				{

					throw new ArgumentOutOfRangeException("index");

				}



				objectList[idx] = value;

				objectTable[value.Key] = value.Value;

			}

		}



		/// <summary>

		/// Get/Set the value associated with the specified key.

		/// </summary>

		/// <param name="key">The key.</param>

		/// <returns>The associated value.</returns>

		public virtual V this[K key]

		{

			get

			{

				return objectTable[key];

			} // get

			set

			{

				if (objectTable.ContainsKey(key))

				{

					objectTable[key] = value;

					objectList[IndexOf(key)] = new KeyValuePair<K, V>(key, value);

				}

				else

				{

					Add(key, value);

				}

			}

		}

		#endregion



		#region ObjectTable (Public)

		/// <summary>

		/// Gets the Dictionary class backing the KeyedList.

		/// </summary>

		public Dictionary<K, V> ObjectTable

		{

			get

			{

				return objectTable;

			} // get

		}

		#endregion



		#region Private



		#region objectTable (Private)

		/// <summary>

		/// Object table

		/// </summary>

		/// <typeparam name="K">K</typeparam>

		/// <typeparam name="V">V</typeparam>

		private readonly Dictionary<K, V> objectTable =

			new Dictionary<K, V>();

		#endregion



		#region objectList (Private)

		/// <summary>

		/// Object list

		/// </summary>

		/// <typeparam name="K">K</typeparam>

		/// <typeparam name="V">V</typeparam>

		private readonly List<KeyValuePair<K, V>> objectList =

			new List<KeyValuePair<K, V>>();

		#endregion



		#endregion



		#region ICollection<KeyValuePair<K,V>> Members

		/// <summary>

		/// Adds a key-value pair to the KeyedList.

		/// </summary>

		/// <param name="kvp">The KeyValuePair instance.</param>

		public void Add(KeyValuePair<K, V> kvp)

		{

			Add(kvp.Key, kvp.Value);

		}



		/// <summary>

		/// Clears all entries in the KeyedList.

		/// </summary>

		public void Clear()

		{

			objectTable.Clear();

			objectList.Clear();

		}



		/// <summary>

		/// Test if the KeyedList contains the key in the key-value pair.

		/// </summary>

		/// <param name="kvp">The key-value pair.</param>

		/// <returns>True if the key is found.</returns>

		public bool Contains(KeyValuePair<K, V> kvp)

		{

			return objectTable.ContainsKey(kvp.Key);

		}



		/// <summary>

		/// Copy the entire key-value pairs to the KeyValuePair array, starting

		/// at the specified index of the target array.  The array is populated 

		/// as an ordered list.

		/// </summary>

		/// <param name="kvpa">The KeyValuePair array.</param>

		/// <param name="idx">The position to start the copy.</param>

		public void CopyTo(KeyValuePair<K, V>[] kvpa, int idx)

		{

			objectList.CopyTo(kvpa, idx);

		}



		/// <summary>

		/// Remove the key in the specified KeyValuePair instance.  The Value

		/// property is ignored.

		/// </summary>

		/// <param name="kvp">The key-value identifying the entry.</param>

		/// <returns>True if removed.</returns>

		public bool Remove(KeyValuePair<K, V> kvp)

		{

			return Remove(kvp.Key);

		}

		#endregion



		#region IDictionary<K,V> Members

		/// <summary>

		/// Adds a key-value pair to the KeyedList.

		/// </summary>

		/// <param name="key">The key.</param>

		/// <param name="value">The associated value.</param>

		public void Add(K key, V value)

		{

			objectTable.Add(key, value);

			objectList.Add(new KeyValuePair<K, V>(key, value));

		}



		/// <summary>

		/// Test if the KeyedList contains the key.

		/// </summary>

		/// <param name="key">The key.</param>

		/// <returns>True if the key is found.</returns>

		public bool ContainsKey(K key)

		{

			return objectTable.ContainsKey(key);

		}



		/// <summary>

		/// Remove the entry.

		/// </summary>

		/// <param name="key">The key identifying the key-value pair.</param>

		/// <returns>True if removed.</returns>

		public bool Remove(K key)

		{

			bool found = objectTable.Remove(key);



			if (found)

			{

				objectList.RemoveAt(IndexOf(key));

			}



			return found;

		}



		/// <summary>

		/// Attempt to get the value, given the key, without throwing an exception

		/// if not found.

		/// </summary>

		/// <param name="key">The key indentifying the entry.</param>

		/// <param name="val">The value, if found.</param>

		/// <returns>True if found.</returns>

		public bool TryGetValue(K key, out V val)

		{

			return objectTable.TryGetValue(key, out val);

		}

		#endregion



		#region IEnumerable Members

		/// <summary>

		/// Returns an ordered System.Collections KeyValuePair objects.

		/// </summary>

		IEnumerator IEnumerable.GetEnumerator()

		{

			return objectList.GetEnumerator();

		}

		#endregion



		#region IEnumerable<KeyValuePair<K,V>> Members

		/// <summary>

		/// Returns an ordered KeyValuePair enumerator.

		/// </summary>

		IEnumerator<KeyValuePair<K, V>> IEnumerable<KeyValuePair<K, V>>.

			GetEnumerator()

		{

			return objectList.GetEnumerator();

		}

		#endregion



		#region IList<KeyValuePair<K,V>> Members

		/// <summary>

		/// Given the key-value pair, find the index.

		/// </summary>

		/// <param name="kvp">The key-value pair.</param>

		/// <returns>The index, or -1 if not found.</returns>

		public int IndexOf(KeyValuePair<K, V> kvp)

		{

			return IndexOf(kvp.Key);

		}



		/// <summary>

		/// Insert the key-value pair at the specified index location.

		/// </summary>

		/// <param name="idx">The key.</param>

		/// <param name="kvp">The value.</param>

		public void Insert(int idx, KeyValuePair<K, V> kvp)

		{

			if ((idx < 0) ||

			    (idx > Count))

			{

				throw new ArgumentOutOfRangeException("index");

			}



			objectTable.Add(kvp.Key, kvp.Value);

			objectList.Insert(idx, kvp);

		}



		/// <summary>

		/// Remove the entry at the specified index.

		/// </summary>

		/// <param name="idx">The index to the entry to be removed.</param>

		public void RemoveAt(int idx)

		{

			if ((idx < 0) ||

			    (idx >= Count))

			{

				throw new ArgumentOutOfRangeException("index");

			}



			objectTable.Remove(objectList[idx].Key);

			objectList.RemoveAt(idx);

		}

		#endregion



		#region GetKey (Public)

		/// <summary>

		/// Returns the key at the specified index.

		/// </summary>

		/// <param name="idx">The index.</param>

		/// <returns>The key at the index.</returns>

		public K GetKey(int idx)

		{

			if (idx < 0 ||

			    idx >= Count)

			{

				throw new ArgumentOutOfRangeException("index");

			}



			return objectList[idx].Key;

		}

		#endregion



		#region GetValue (Public)

		/// <summary>

		/// Returns the value at the specified index.

		/// </summary>

		/// <param name="idx">The index.</param>

		/// <returns>The value at the index.</returns>

		public V GetValue(int idx)

		{

			if (idx < 0 ||

			    idx >= Count)

			{

				throw new ArgumentOutOfRangeException("index");

			}



			return objectList[idx].Value;

		}

		#endregion



		#region IndexOf (Public)

		/// <summary>

		/// Get the index of a particular key.

		/// </summary>

		/// <param name="key">The key to find the index of.</param>

		/// <returns>The index of the key, or -1 if not found.</returns>

		public int IndexOf(K key)

		{

			int ret = -1;



			for (int i = 0; i < objectList.Count; i++)

			{

				if (objectList[i].Key.Equals(key))

				{

					ret = i;

					break;

				}

			}



			return ret;

		}

		#endregion



		#region Insert (Public)

		/// <summary>

		/// Insert the key-value at the specified index.

		/// </summary>

		/// <param name="idx">The zero-based insert point.</param>

		/// <param name="key">The key.</param>

		/// <param name="value">The value.</param>

		public void Insert(int idx, K key, V value)

		{

			if ((idx < 0) ||

			    (idx > Count))

			{

				throw new ArgumentOutOfRangeException("index");

			}



			objectTable.Add(key, value);

			objectList.Insert(idx, new KeyValuePair<K, V>(key, value));

		}

		#endregion

	}



	/// <summary>

	/// Keyed list tests, must be declared outside of a generic class.

	/// </summary>

	internal class KeyedListTests

	{

		#region Helpers



		#region k

		/// <summary>

		/// KeyedList for testing ..

		/// </summary>

		protected static KeyedList<string, int> k;

		#endregion



		#region .ctor

		/// <summary>

		/// KeyedListTests

		/// </summary>

		public KeyedListTests()

		{

			k = new KeyedList<string, int>();

			k.Add("Zero", 0);

			k.Add("One", 1);

			k.Add("Two", 2);

			k.Add("Three", 3);

			k.Add("Four", 4);

			k.Add("Five", 5);

			k.Add("Six", 6);

			k.Add("Seven", 7);

			k.Add("Eight", 8);

			k.Add("Nine", 9);

			k.Add("Ten", 10);

		}

		#endregion



		#endregion



		#region NegativeIndexTest (Static)

		/// <summary>

		/// Negative index test. Note: Too slow for a dynamic unit test.

		/// </summary>

		[Test]

		public static void NegativeIndexTest()

		{

			Assert.Throws(typeof(ArgumentOutOfRangeException),

				delegate

				{

					int foo = k[-1].Value;

				});

		}

		#endregion



		#region ValueIteratorTest

		/// <summary>

		/// Value iterator test

		/// </summary>

		[Test]

		public void ValueIteratorTest()

		{

			int idx = 0;



			foreach (int val in k.Values)

			{

				Assert.True(val == idx, "Itereator: Expected " + idx.ToString());

				++idx;

			}

		}

		#endregion



		#region ValueByIndexTests

		/// <summary>

		/// Value by index tests

		/// </summary>

		[Test]

		public void ValueByIndexTests()

		{

			Assert.True(k[0].Value == 0, "Indexer: Expected 0");

			Assert.True(k[1].Value == 1, "Indexer: Expected 1");

			Assert.True(k[2].Value == 2, "Indexer: Expected 2");

			Assert.True(k[3].Value == 3, "Indexer: Expected 3");

			Assert.True(k[4].Value == 4, "Indexer: Expected 4");

			Assert.True(k[5].Value == 5, "Indexer: Expected 5");

			Assert.True(k[6].Value == 6, "Indexer: Expected 6");

			Assert.True(k[7].Value == 7, "Indexer: Expected 7");

			Assert.True(k[8].Value == 8, "Indexer: Expected 8");

			Assert.True(k[9].Value == 9, "Indexer: Expected 9");

			Assert.True(k[10].Value == 10, "Indexer: Expected 10");

		}

		#endregion



		#region ValueByKeyTests

		/// <summary>

		/// Value by key tests

		/// </summary>

		[Test]

		public void ValueByKeyTests()

		{

			Assert.True(k["Zero"] == 0, "Lookup: Expected 0");

			Assert.True(k["One"] == 1, "Lookup: Expected 1");

			Assert.True(k["Two"] == 2, "Lookup: Expected 2");

			Assert.True(k["Three"] == 3, "Lookup: Expected 3");

			Assert.True(k["Four"] == 4, "Lookup: Expected 4");

			Assert.True(k["Five"] == 5, "Lookup: Expected 5");

			Assert.True(k["Six"] == 6, "Lookup: Expected 6");

			Assert.True(k["Seven"] == 7, "Lookup: Expected 7");

			Assert.True(k["Eight"] == 8, "Lookup: Expected 8");

			Assert.True(k["Nine"] == 9, "Lookup: Expected 9");

			Assert.True(k["Ten"] == 10, "Lookup: Expected 10");

		}

		#endregion



		#region IndexOfTests

		/// <summary>

		/// Index of tests

		/// </summary>

		[Test]

		public void IndexOfTests()

		{

			Assert.True(k.IndexOf("Zero") == 0, "IndexOf: Expected 0");

			Assert.True(k.IndexOf("One") == 1, "IndexOf: Expected 1");

			Assert.True(k.IndexOf("Two") == 2, "IndexOf: Expected 2");

			Assert.True(k.IndexOf("Three") == 3, "IndexOf: Expected 3");

			Assert.True(k.IndexOf("Four") == 4, "IndexOf: Expected 4");

			Assert.True(k.IndexOf("Five") == 5, "IndexOf: Expected 5");

			Assert.True(k.IndexOf("Six") == 6, "IndexOf: Expected 6");

			Assert.True(k.IndexOf("Seven") == 7, "IndexOf: Expected 7");

			Assert.True(k.IndexOf("Eight") == 8, "IndexOf: Expected 8");

			Assert.True(k.IndexOf("Nine") == 9, "IndexOf: Expected 9");

			Assert.True(k.IndexOf("Ten") == 10, "IndexOf: Expected 10");

		}

		#endregion



		#region ContainsKeyTests

		/// <summary>

		/// Contains key tests

		/// </summary>

		[Test]

		public void ContainsKeyTests()

		{

			Assert.True(k.ContainsKey("Zero"), "Expected true");

			Assert.True(k.ContainsKey("One"), "Expected true");

			Assert.True(k.ContainsKey("Two"), "Expected true");

			Assert.True(k.ContainsKey("Three"), "Expected true");

			Assert.True(k.ContainsKey("Four"), "Expected true");

			Assert.True(k.ContainsKey("Five"), "Expected true");

			Assert.True(k.ContainsKey("Six"), "Expected true");

			Assert.True(k.ContainsKey("Seven"), "Expected true");

			Assert.True(k.ContainsKey("Eight"), "Expected true");

			Assert.True(k.ContainsKey("Nine"), "Expected true");

			Assert.True(k.ContainsKey("Ten"), "Expected true");

		}

		#endregion



		#region ContainsTests

		/// <summary>

		/// Contains tests

		/// </summary>

		[Test]

		public void ContainsTests()

		{

			Assert.True(k.Contains(

				new KeyValuePair<string, int>("Zero", 0)), "Expected true");

			Assert.True(k.Contains(

				new KeyValuePair<string, int>("One", 1)), "Expected true");

			Assert.True(k.Contains(

				new KeyValuePair<string, int>("Two", 2)), "Expected true");

			Assert.True(k.Contains(

				new KeyValuePair<string, int>("Three", 3)), "Expected true");

			Assert.True(k.Contains(

				new KeyValuePair<string, int>("Four", 4)), "Expected true");

			Assert.True(k.Contains(

				new KeyValuePair<string, int>("Five", 5)), "Expected true");

			Assert.True(k.Contains(

				new KeyValuePair<string, int>("Six", 6)), "Expected true");

			Assert.True(k.Contains(

				new KeyValuePair<string, int>("Seven", 7)), "Expected true");

			Assert.True(k.Contains(

				new KeyValuePair<string, int>("Eight", 8)), "Expected true");

			Assert.True(k.Contains(

				new KeyValuePair<string, int>("Nine", 9)), "Expected true");

			Assert.True(k.Contains(

				new KeyValuePair<string, int>("Ten", 10)), "Expected true");

		}

		#endregion



		#region NotContainsKeyTest

		/// <summary>

		/// Does not contains key test

		/// </summary>

		[Test]

		public void NotContainsKeyTest()

		{

			Assert.False(k.ContainsKey("Eleven"), "Expected false");

		}

		#endregion



		#region NotContainsTests

		/// <summary>

		/// Does not contains tests

		/// </summary>

		[Test]

		public void NotContainsTests()

		{

			Assert.True(k.Contains(

				new KeyValuePair<string, int>("Zero", 5)),

				"List does not contain kvp Zero-5, but Contains returned true!");

			Assert.False(k.Contains(

				new KeyValuePair<string, int>("Eleven", 11)),

				"List does contain kvp Eleven-11, but it was not found!");

		}

		#endregion



		#region OrderedKeyTest

		/// <summary>

		/// Ordered key test

		/// </summary>

		[Test]

		public void OrderedKeyTest()

		{

			int idx = 0;



			foreach (string key in k.OrderedKeys)

			{

				Assert.True(key == k.GetKey(idx++),

					"Expected key to match indexed key.");

			}

		}

		#endregion



		#region OrderedValueTest

		/// <summary>

		/// Ordered value test

		/// </summary>

		[Test]

		public void OrderedValueTest()

		{

			int idx = 0;



			foreach (int val in k.OrderedValues)

			{

				Assert.True(val == k[idx++].Value,

					"Expected value to match indexed value.");

			}

		}

		#endregion



		#region IndexToLargeTest

		/// <summary>

		/// Index to large test

		/// </summary>

		[Test]

		public void IndexToLargeTest()

		{

			Assert.Throws(typeof(ArgumentOutOfRangeException),

				delegate

				{

					int foo = k[k.Count].Value;

				});

		}

		#endregion



		#region BadKeyTest

		/// <summary>

		/// Bad key test

		/// </summary>

		[Test]

		public void BadKeyTest()

		{

			Assert.Throws(typeof(KeyNotFoundException),

				delegate

				{

					int foo = k["Eleven"];

				});

		}

		#endregion



		#region IndexOfNotFound

		/// <summary>

		/// Index of not found

		/// </summary>

		[Test]

		public void IndexOfNotFound()

		{

			Assert.True(k.IndexOf("Foo") == -1,

				"Expected the returned index to be -1.");

		}

		#endregion

	}



	/// <summary>

	/// Sequenced keyed list tests

	/// </summary>

	internal class SequencedKeyedListTests

	{

		#region Helpers



		#region k

		/// <summary>

		/// K

		/// </summary>

		protected KeyedList<string, double> k;

		#endregion



		#region .ctor

		/// <summary>

		/// Fixture setup

		/// </summary>

		public SequencedKeyedListTests()

		{

			FillList();

		}

		#endregion



		#region FillList

		private void FillList()

		{

			k = new KeyedList<string, double>();

			k.Add("Zero", 0);

			k.Add("One", 1);

			k.Add("Two", 2);

			k.Add("Three", 3);

			k.Add("Four", 4);

			k.Add("Five", 5);

			k.Add("Six", 6);

			k.Add("Seven", 7);

			k.Add("Eight", 8);

			k.Add("Nine", 9);

			k.Add("Ten", 10);

		}

		#endregion



		#endregion



		#region CopyToTest

		/// <summary>

		/// Copy to test

		/// </summary>

		[Test]

		public void CopyToTest()

		{

			FillList();

			KeyValuePair<string, double>[] kvpa =

				new KeyValuePair<string, double>[k.Count];

			k.CopyTo(kvpa, 0);

			int idx = 0;



			foreach (KeyValuePair<string, double> kvp in kvpa)

			{

				Assert.True(kvp.Key == k.GetKey(idx),

					"KeyValuePair not ordered.");

				Assert.True(kvp.Value == k[idx].Value,

					"KeyValuePair not ordered.");

				++idx;

			}

		}

		#endregion



		#region CopyToArraySizeExceptionTest

		/// <summary>

		/// Copy to array size exception test

		/// </summary>

		[Test]

		public void CopyToArraySizeExceptionTest()

		{

			Assert.Throws(typeof(ArgumentException),

				delegate

				{

					KeyValuePair<string, double>[] kvpa =

						new KeyValuePair<string, double>[k.Count];

					k.CopyTo(kvpa, 5);

				});

		}

		#endregion



		#region AddTest

		/// <summary>

		/// Add test

		/// </summary>

		[Test]

		public void AddTest()

		{

			FillList();

			k.Add("Eleven", 11);

			Assert.True(k[k.Count - 1].Value == 11,

				"Expected the last entry to be 11.");

		}

		#endregion



		#region AddTestByKeyValuePair

		/// <summary>

		/// Add test by key value pair

		/// </summary>

		[Test]

		public void AddTestByKeyValuePair()

		{

			FillList();

			k.Add(new KeyValuePair<string, double>("Twelve", 12));

			Assert.True(k[k.Count - 1].Value == 12,

				"Expected the last entry to be 12.");

		}

		#endregion



		#region InsertTest

		/// <summary>

		/// Insert test

		/// </summary>

		[Test]

		public void InsertTest()

		{

			FillList();

			k.Insert(2, "One Point Five", 1.5);

			Assert.True(k[1].Value == 1, "Expected [1] entry to = 1");

			Assert.True(k[2].Value == 1.5, "Expected [2] entry to = 1.5");

			Assert.True(k[3].Value == 2, "Expected [3] entry to = 2");

		}

		#endregion



		#region RemoveNotFoundTest

		/// <summary>

		/// Remove not found test

		/// </summary>

		[Test]

		public void RemoveNotFoundTest()

		{

			FillList();

			bool ret = k.Remove("One Point Five");

			Assert.True(!ret, "Expected false");

		}

		#endregion



		#region RemoveByKeyValuePair

		/// <summary>

		/// Remove by key value pair

		/// </summary>

		[Test]

		public void RemoveByKeyValuePair()

		{

			FillList();

			k.Add("Eleven", 11);

			k.Add("Twelve", 12);



			KeyValuePair<string, double> kvp =

				new KeyValuePair<string, double>("Eleven", 11);

			bool ret = k.Remove(kvp);

			Assert.True(ret, "Expected true");

			Assert.True(k[11].Value == 12,

				"Expected entry 11 to be removed");

		}

		#endregion



		#region RemoveNotFoundByKeyValuePair

		/// <summary>

		/// Remove not found by key value pair

		/// </summary>

		[Test]

		public void RemoveNotFoundByKeyValuePair()

		{

			FillList();

			// value is ignored.

			KeyValuePair<string, double> kvp =

				new KeyValuePair<string, double>("Eleven", 0);

			bool ret = k.Remove(kvp);

			Assert.True(!ret, "Expected false");

		}

		#endregion



		#region RemoveAtTest

		/// <summary>

		/// Remove at test

		/// </summary>

		[Test]

		public void RemoveAtTest()

		{

			FillList();

			k.RemoveAt(1);

			Assert.True(k[0].Value == 0, "Expected [0] entry to = 0");

			Assert.True(k[1].Value == 2, "Expected [1] entry to = 2");

		}

		#endregion



		#region TryGetValueTest

		/// <summary>

		/// Try get value test

		/// </summary>

		[Test]

		public void TryGetValueTest()

		{

			FillList();

			double v;

			bool ret = k.TryGetValue("Ten", out v);

			Assert.True(ret, "Expected true");

			Assert.True(v == 10, "Expected return value = 10");

		}

		#endregion



		#region TryGetValueNotFoundTest

		/// <summary>

		/// Try get value not found test

		/// </summary>

		[Test]

		public void TryGetValueNotFoundTest()

		{

			FillList();

			double v;

			bool ret = k.TryGetValue("Elevent", out v);

			Assert.True(!ret, "Expected false");

			Assert.True(v == 0, "Expected return value = default value");

		}

		#endregion



		#region EmptyListInsertAtZero

		/// <summary>

		/// Empty list insert at zero

		/// </summary>

		[Test]

		public void EmptyListInsertAtZero()

		{

			k.Clear();

			k.Insert(0, "Z", 0);

			Assert.True(k[0].Value == 0, "Expected a value of 0");

		}

		#endregion



		#region RemoveTest

		/// <summary>

		/// Remove test

		/// </summary>

		[Test]

		public void RemoveTest()

		{

			FillList();

			bool ret = k.Remove("One");// Point Five");

			Assert.True(ret, "Expected true");

			Assert.Equal(0, k[0].Value);

			Assert.Equal(2, k[1].Value);

			Assert.Equal(3, k[2].Value);

		}

		#endregion

	}



	/// <summary>

	/// Enumerator tests

	/// </summary>

	internal class EnumeratorTests

	{

		#region Helpers



		#region k

		/// <summary>

		/// K

		/// </summary>

		protected KeyedList<string, int> k;

		#endregion



		#region .ctor

		/// <summary>

		/// Fixture setup

		/// </summary>

		public EnumeratorTests()

		{

			k = new KeyedList<string, int>();

			k.Add("Zero", 0);

			k.Add("One", 1);

			k.Add("Two", 2);

			k.Add("Three", 3);

			k.Add("Four", 4);

			k.Add("Five", 5);

			k.Add("Six", 6);

			k.Add("Seven", 7);

			k.Add("Eight", 8);

			k.Add("Nine", 9);

			k.Add("Ten", 10);

		}

		#endregion



		#endregion



		#region DefaultEnumerator

		/// <summary>

		/// Default enumerator

		/// </summary>

		[Test]

		public void DefaultEnumerator()

		{

			foreach (object obj in k)

			{

			}

		}

		#endregion



		#region EnumerationTest

		/// <summary>

		/// Enumeration test

		/// </summary>

		[Test]

		public void EnumerationTest()

		{

			int n = 0;



			foreach (KeyValuePair<string, int> kvp in k)

			{

				Assert.True(kvp.Value == n, "Expected ordered list of values.");

				++n;

			}

		}

		#endregion



		#region ValueEnumeratorTest

		/// <summary>

		/// Value enumerator test

		/// </summary>

		[Test]

		public void ValueEnumeratorTest()

		{

			int n = 0;



			foreach (int i in k.OrderedValues)

			{

				Assert.True(n == i, "Expected ordered list of values.");

				++n;

			}

		}

		#endregion



		#region KeyEnumeratorTest

		/// <summary>

		/// Key enumerator test

		/// </summary>

		[Test]

		public void KeyEnumeratorTest()

		{

			int n = 0;



			foreach (string s in k.OrderedKeys)

			{

				Assert.True(k.GetKey(n) == s, "Expected ordered list of keys.");

				++n;

			}

		}

		#endregion

	}

}