[Adapdev-commits] Adapdev/src/Adapdev.Tests/Reflection ClassAccessorCacheTest.cs,1.2,1.3 ClassAccessorTest.cs,1.2,1.3 FieldAccessorTest.cs,1.2,1.3 FieldAccessorTestObject.cs,1.2,1.3 PropertyAccessorTest.cs,1.2,1.3 PropertyAccessorTestObject.cs,1.2,1.3

[Sean M. <int...@us...>]

Update of /cvsroot/adapdev/Adapdev/src/Adapdev.Tests/Reflection
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv909/src/Adapdev.Tests/Reflection

Added Files:
	ClassAccessorCacheTest.cs ClassAccessorTest.cs 
	FieldAccessorTest.cs FieldAccessorTestObject.cs 
	PropertyAccessorTest.cs PropertyAccessorTestObject.cs 
Log Message:


--- NEW FILE: FieldAccessorTestObject.cs ---
using System;

namespace Adapdev.Reflection.Tests
{
	using System.Collections;

	/// <summary>
	/// Summary description for FieldAccessorthis.
	/// </summary>
	public class FieldAccessorTestObject
	{
		private static readonly int TEST_INTEGER = 319;
		private static readonly string TEST_STRING = "Test string.";
		private static readonly sbyte TEST_SBYTE = 12;
		private static readonly byte TEST_BYTE = 234;
		private static readonly char TEST_CHAR = 'a';
		private static readonly short TEST_SHORT = -673;
		private static readonly ushort TEST_USHORT = 511;
		private static readonly long TEST_LONG = 8798798798;
		private static readonly ulong TEST_ULONG = 918297981798;
		private static readonly bool TEST_BOOL = false;
		private static readonly double TEST_DOUBLE = 789.12;
		private static readonly float TEST_FLOAT = 123.12F;
		private static readonly DateTime TEST_DATETIME = new DateTime(2005, 3, 6);
		private static readonly decimal TEST_DECIMAL = new decimal(98798798.1221);
		private static readonly int[] TEST_ARRAY = new int[]{1,2,3};

		public FieldAccessorTestObject()
		{
			this.mInt = TEST_INTEGER;
			this.mString = TEST_STRING;
			this.mBool = TEST_BOOL;
			this.mByte = TEST_BYTE;
			this.mChar = TEST_CHAR;
			this.mDateTime = TEST_DATETIME;
			this.mDecimal = TEST_DECIMAL;
			this.mDouble = TEST_DOUBLE;
			this.mFloat = TEST_FLOAT;
			this.mLong = TEST_LONG;
			this.mSbyte = TEST_SBYTE;
			this.mShort = TEST_SHORT;
			this.mUlong = TEST_ULONG;
			this.mUshort = TEST_USHORT;
			this.mList = new ArrayList(TEST_ARRAY);			
		}

		public int Int
		{
			get
			{
				return this.mInt;
			}
		}

		public string String
		{
			get
			{
				return this.mString;
			}
		}

		public sbyte Sbyte
		{
			get
			{
				return this.mSbyte;
			}
		}

		public byte Byte
		{
			get
			{
				return this.mByte;
			}
		}

		public char Char
		{
			get
			{
				return this.mChar;
			}
		}

		public short Short
		{
			get
			{
				return this.mShort;
			}
		}

		public ushort UShort
		{
			get
			{
				return this.mUshort;
			}
		}

		public long Long
		{
			get
			{
				return this.mLong;
			}
		}

		public ulong ULong
		{
			get
			{
				return this.mUlong;
			}
		}

		public bool Bool
		{
			get
			{
				return this.mBool;
			}
		}

		public double Double
		{
			get
			{
				return this.mDouble;
			}
		}

		public float Float
		{
			get
			{
				return this.mFloat;
			}
		}

		public DateTime DateTime
		{
			get
			{
				return this.mDateTime;
			}
		}

		public decimal Decimal
		{
			get
			{
				return this.mDecimal;
			}
		}

		public IList List
		{
			get
			{
				return this.mList;
			}
		}

		public int ReadOnlyInt
		{
			get
			{
				return this.mReadOnlyInt;
			}
		}

		public int WriteOnlyInt
		{
			set
			{
				this.mWriteOnlyInt = value;	
			}
		}


		public int mInt;
		public string mString;
		public sbyte mSbyte;
		public byte mByte;
		public char mChar;
		public short mShort;
		public ushort mUshort;
		public long mLong;
		public ulong mUlong;
		public bool mBool;
		public double mDouble;
		public float mFloat;
		public DateTime mDateTime;
		public decimal mDecimal;
		public IList mList;
		public int mReadOnlyInt = 0;
		public int mWriteOnlyInt;
	}
}

--- NEW FILE: ClassAccessorCacheTest.cs ---
using System;
using NUnit.Framework;
using Adapdev.Reflection;

namespace Adapdev.Reflection.Tests
{
	/// <summary>
	/// Summary description for IValidatable.
	/// </summary>
	/// 
	[TestFixture]
	public class ClassAccessorCacheTest
	{
		[SetUp]
		public void Clear()
		{
			ClassAccessorCache.Clear();
		}

		[Test]
		public void GetByType()
		{
			ClassAccessor c = ClassAccessorCache.Get(typeof(PropertyAccessorTestObject));
			Assert.IsNotNull(c);
			Assert.AreEqual(typeof(PropertyAccessorTestObject), c.Type);
		}

		[Test]
		public void GetByObject()
		{
			PropertyAccessorTestObject o = new PropertyAccessorTestObject();
			ClassAccessor c = ClassAccessorCache.Get(o);
			Assert.IsNotNull(c);
			Assert.AreEqual(o.GetType(), c.Type);
		}

		[Test]
		public void Count()
		{
			PropertyAccessorTestObject o = new PropertyAccessorTestObject();
			ClassAccessor c = ClassAccessorCache.Get(o);
			Assert.AreEqual(1, ClassAccessorCache.Count);
		}

		[Test]
		public void Remove()
		{
			PropertyAccessorTestObject o = new PropertyAccessorTestObject();
			ClassAccessor c = ClassAccessorCache.Get(o);
			Assert.AreEqual(1, ClassAccessorCache.Count);
			ClassAccessorCache.Remove(c.Type);
			Assert.AreEqual(0, ClassAccessorCache.Count);
		}

		[Test]
		public void ShowToString()
		{
			PropertyAccessorTestObject o = new PropertyAccessorTestObject();
			ClassAccessor c = ClassAccessorCache.Get(o);
			c.LoadAllProperties();
			Console.WriteLine(ClassAccessorCache.ToString());
		}
	}

}

--- NEW FILE: PropertyAccessorTest.cs ---
//
// Author: James Nies
// Date: 3/22/2005
// Description: This class is a NUnit test for the PropertyAccessor class and
//		requires the NUnit framework.
//
// *** This code was written by James Nies and has been provided to you, ***
// *** free of charge, for your use.  I assume no responsibility for any ***
// *** undesired events resulting from the use of this code or the		 ***
// *** information that has been provided with it .						 ***
//
using System;
using System.Collections;
using System.Reflection;


using NUnit.Framework;
using Adapdev.Reflection;

namespace Adapdev.Reflection.Tests
{
	/// <summary>
	/// Test fixture for the PropertyAccessor class.
	/// </summary>
	[TestFixture]
	public class PropertyAccessorTest
	{
#region Test Constants

		private static readonly int TEST_INTEGER = 319;
		private static readonly string TEST_STRING = "Test string.";
		private static readonly sbyte TEST_SBYTE = 12;
		private static readonly byte TEST_BYTE = 234;
		private static readonly char TEST_CHAR = 'a';
		private static readonly short TEST_SHORT = -673;
		private static readonly ushort TEST_USHORT = 511;
		private static readonly long TEST_LONG = 8798798798;
		private static readonly ulong TEST_ULONG = 918297981798;
		private static readonly bool TEST_BOOL = false;
		private static readonly double TEST_DOUBLE = 789.12;
		private static readonly float TEST_FLOAT = 123.12F;
		private static readonly DateTime TEST_DATETIME = new DateTime(2005, 3, 6);
		private static readonly decimal TEST_DECIMAL = new decimal(98798798.1221);
		private static readonly int[] TEST_ARRAY = new int[]{1,2,3};

#endregion Test Constants
		
#region Test Get And Set

		[Test]
		public void TestGetInteger()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Int");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Int, propertyAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetInteger()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Int");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			int testInt = 2345;
			propertyAccessor.Set(testObject, testInt);
			Assert.AreEqual(testInt, testObject.Int);			
		}

		[Test]
		public void TestGetString()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"String");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.String, propertyAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetString()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"String");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			string testString = "New string";
			propertyAccessor.Set(testObject, testString);
			Assert.AreEqual(testString, testObject.String);			
		}

		[Test]
		public void TestGetBool()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Bool");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Bool, propertyAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetBool()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Bool");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			bool testBool = true;
			propertyAccessor.Set(testObject, testBool);
			Assert.AreEqual(testBool, testObject.Bool);			
		}

		[Test]
		public void TestGetByte()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Byte");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Byte, propertyAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetByte()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Byte");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			byte testByte = 16;
			propertyAccessor.Set(testObject, testByte);
			Assert.AreEqual(testByte, testObject.Byte);			
		}

		[Test]
		public void TestGetChar()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Char");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Char, propertyAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetChar()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Char");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			char testChar = 'Z';
			propertyAccessor.Set(testObject, testChar);
			Assert.AreEqual(testChar, testObject.Char);			
		}

		[Test]
		public void TestGetDateTime()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"DateTime");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.DateTime, propertyAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetDateTime()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"DateTime");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			DateTime testDateTime = DateTime.Now;
			propertyAccessor.Set(testObject, testDateTime);
			Assert.AreEqual(testDateTime, testObject.DateTime);			
		}

		[Test]
		public void TestGetDecimal()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Decimal");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Decimal, propertyAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetDecimal()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Decimal");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			decimal testDecimal = new decimal(123123.12);
			propertyAccessor.Set(testObject, testDecimal);
			Assert.AreEqual(testDecimal, testObject.Decimal);			
		}

		[Test]
		public void TestGetDouble()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Double");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Double, propertyAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetDouble()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Double");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			double testDouble = 9999.99;
			propertyAccessor.Set(testObject, testDouble);
			Assert.AreEqual(testDouble, testObject.Double);			
		}

		[Test]
		public void TestGetFloat()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Float");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Float, propertyAccessor.Get(testObject));			
		}
		
		[Test]
		public void TestSetFloat()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Float");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			float testFloat = 1982.12F;
			propertyAccessor.Set(testObject, testFloat);
			Assert.AreEqual(testFloat, testObject.Float);			
		}
		
		[Test]
		public void TestGetLong()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Long");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Long, propertyAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetLong()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Long");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			long testLong = 92873987232;
			propertyAccessor.Set(testObject, testLong);
			Assert.AreEqual(testLong, testObject.Long);			
		}

		[Test]
		public void TestGetSbyte()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Sbyte");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Sbyte, propertyAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetSbyte()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Sbyte");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			sbyte testSbyte = 19;
			propertyAccessor.Set(testObject, testSbyte);
			Assert.AreEqual(testSbyte, testObject.Sbyte);			
		}

		[Test]
		public void TestGetShort()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Short");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Short, propertyAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetShort()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Short");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			short testShort = 2378;
			propertyAccessor.Set(testObject, testShort);
			Assert.AreEqual(testShort, testObject.Short);			
		}
		
		[Test]
		public void TestGetULong()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"ULong");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.ULong, propertyAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetULong()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"ULong");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			ulong testULong = 29837987298;
			propertyAccessor.Set(testObject, testULong);
			Assert.AreEqual(testULong, testObject.ULong);			
		}
		
		[Test]
		public void TestGetUShort()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"UShort");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.UShort, propertyAccessor.Get(testObject));			
		}
		
		[Test]
		public void TestSetUShort()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"UShort");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			ushort testUShort = 789;
			propertyAccessor.Set(testObject, testUShort);
			Assert.AreEqual(testUShort, testObject.UShort);			
		}

		[Test]
		public void TestGetList()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"List");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.List, propertyAccessor.Get(testObject));			
		}
		
		[Test]
		public void TestSetList()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"List");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			ArrayList list = new ArrayList(new int[]{4,5,6});
			propertyAccessor.Set(testObject, list);
			Assert.AreEqual(list, testObject.List);			
		}


#endregion Test Get And Set

		[Test]
		public void TestTargetType()
		{
			PropertyAccessor propertyAccessor
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Int");

			Assert.AreEqual(typeof(PropertyAccessorTestObject),
				propertyAccessor.TargetType);
		}

		[Test]
		public void TestPropertyType()
		{
			PropertyAccessor propertyAccessor
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Int");

			Assert.AreEqual(typeof(int),
				propertyAccessor.PropertyType);
		}

		[Test]
		public void TestCanRead()
		{
			PropertyAccessor propertyAccessor;

			//
			// Can read
			//
			propertyAccessor = new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Int");

			Assert.IsTrue(propertyAccessor.CanRead);

			//
			// Cannot read
			//
			propertyAccessor = new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"WriteOnlyInt");

			Assert.IsFalse(propertyAccessor.CanRead);
		}

		[Test]
		public void TestCanWrite()
		{
			PropertyAccessor propertyAccessor;

			//
			// Can read
			//
			propertyAccessor = new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"Int");

			Assert.IsTrue(propertyAccessor.CanWrite);

			//
			// Cannot write
			//
			propertyAccessor = new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"ReadOnlyInt");

			Assert.IsFalse(propertyAccessor.CanWrite);
		}

		[Test]
		[ExpectedException(typeof(PropertyAccessorException),
			 "Property \"ReadOnlyInt\" does not have a set method.")]
		public void TestSetNotSupported()
		{
			PropertyAccessor propertyAccessor 
			= new PropertyAccessor(typeof(PropertyAccessorTestObject),
			"ReadOnlyInt");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			//
			// Attempt to set a propert that is read only
			//
			propertyAccessor.Set(testObject, 123);	
		}

		[Test]
		[ExpectedException(typeof(PropertyAccessorException),
			 "Property \"WriteOnlyInt\" does not have a get method.")]
		public void TestGetNotSupported()
		{
			PropertyAccessor propertyAccessor 
				= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"WriteOnlyInt");

			PropertyAccessorTestObject testObject =
				this.CreateTestObject();

			//
			// Attempt read a write-only property
			//
			int test = (int)propertyAccessor.Get(testObject);	
		}

		[Test]
		[ExpectedException(typeof(PropertyAccessorException), 
			"Property \"NonExistantProperty\" does not exist for "
			+ "type Adapdev.Reflection.Tests.PropertyAccessorTestObject.")]
		public void TestNonExistantProperty()
		{
			PropertyAccessor propertyAccessor 
			= new PropertyAccessor(typeof(PropertyAccessorTestObject),
				"NonExistantProperty");
		}

		[Test]
		public void TestGetIntegerPerformance()
		{
			const int TEST_ITERATIONS = 1000000;

			PropertyAccessorTestObject testObject 
				= this.CreateTestObject();

			int test;

			//
			// Property accessor
			//
			DateTime start = DateTime.Now;

			PropertyAccessor propertyAccessor = 
				new PropertyAccessor(typeof(PropertyAccessorTestObject), "Int");
			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				test = (int)propertyAccessor.Get(testObject);
			}

			DateTime end = DateTime.Now;
			
			TimeSpan time = end - start;
			double propertyAccessorMs = time.TotalMilliseconds;

			//
			// Direct access
			//
			start = DateTime.Now;

			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				test = testObject.Int;
			}

			end = DateTime.Now;
			
			time = end - start;
			double directAccessMs = time.TotalMilliseconds;

			//
			// Reflection
			//
			start = DateTime.Now;
			Type type = testObject.GetType();
			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				test = (int)type.InvokeMember("Int", 
					BindingFlags.Public | BindingFlags.GetProperty | BindingFlags.Instance, 
					null, testObject, null);
			}

			end = DateTime.Now;
			
			time = end - start;
			double reflectionMs = time.TotalMilliseconds;
			
			//
			// Print results
			//
			Console.WriteLine(
				TEST_ITERATIONS.ToString() + " property gets on integer..." 
				+ "\nDirect access ms: \t\t\t\t\t" + directAccessMs.ToString()
				+ "\nPropertyAccessor (Reflection.Emit) ms: \t\t" + propertyAccessorMs.ToString() 
				+ "\nReflection ms: \t\t\t\t\t" + reflectionMs.ToString());
		}

		[Test]
		public void TestSetIntegerPerformance()
		{
			const int TEST_ITERATIONS = 1000000;
			const int TEST_VALUE = 123;

			PropertyAccessorTestObject testObject 
				= this.CreateTestObject();

			//
			// Property accessor
			//
			DateTime start = DateTime.Now;

			PropertyAccessor propertyAccessor = 
				new PropertyAccessor(typeof(PropertyAccessorTestObject), "Int");
			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				propertyAccessor.Set(testObject, TEST_VALUE);
			}

			DateTime end = DateTime.Now;
			
			TimeSpan time = end - start;
			double propertyAccessorMs = time.TotalMilliseconds;

			//
			// Direct access
			//
			start = DateTime.Now;

			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				testObject.Int = TEST_VALUE;
			}

			end = DateTime.Now;
			
			time = end - start;
			double directAccessMs = time.TotalMilliseconds;

			//
			// Reflection
			//
			start = DateTime.Now;
			Type type = testObject.GetType();
			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				type.InvokeMember("Int", 
					BindingFlags.Public | BindingFlags.SetProperty | BindingFlags.Instance, 
					null, testObject, new object[]{TEST_VALUE});
			}

			end = DateTime.Now;
			
			time = end - start;
			double reflectionMs = time.TotalMilliseconds;
			
			//
			// Print results
			//
			Console.WriteLine(
				TEST_ITERATIONS.ToString() + " property sets on integer..." 
				+ "\nDirect access ms: \t\t\t\t\t" + directAccessMs.ToString()
				+ "\nPropertyAccessor (Reflection.Emit) ms: \t\t" + propertyAccessorMs.ToString() 
				+ "\nReflection ms: \t\t\t\t\t" + reflectionMs.ToString());
		}

		[Test]
		public void TestGetStringPerformance()
		{
			const int TEST_ITERATIONS = 1000000;

			PropertyAccessorTestObject testObject 
				= this.CreateTestObject();

			string test;

			//
			// Property accessor
			//
			DateTime start = DateTime.Now;

			PropertyAccessor propertyAccessor = 
				new PropertyAccessor(typeof(PropertyAccessorTestObject), "String");
			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				test = (string)propertyAccessor.Get(testObject);
			}

			DateTime end = DateTime.Now;
			
			TimeSpan time = end - start;
			double propertyAccessorMs = time.TotalMilliseconds;

			//
			// Direct access
			//
			start = DateTime.Now;

			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				test = testObject.String;
			}

			end = DateTime.Now;
			
			time = end - start;
			double directAccessMs = time.TotalMilliseconds;

			//
			// Reflection
			//
			start = DateTime.Now;
			Type type = testObject.GetType();
			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				test = (string)type.InvokeMember("String", 
					BindingFlags.Public | BindingFlags.GetProperty | BindingFlags.Instance, 
					null, testObject, null);
			}

			end = DateTime.Now;
			
			time = end - start;
			double reflectionMs = time.TotalMilliseconds;
			
			//
			// Print results
			//
			Console.WriteLine(
				TEST_ITERATIONS.ToString() + " property gets on string..." 
				+ "\nDirect access ms: \t\t\t\t\t" + directAccessMs.ToString()
				+ "\nPropertyAccessor (Reflection.Emit) ms: \t\t" + propertyAccessorMs.ToString() 
				+ "\nReflection ms: \t\t\t\t\t" + reflectionMs.ToString());
		}

		[Test]
		public void TestSetStringPerformance()
		{
			const int TEST_ITERATIONS = 1000000;
			const string TEST_VALUE = "Test";

			PropertyAccessorTestObject testObject 
				= this.CreateTestObject();

			//
			// Property accessor
			//
			DateTime start = DateTime.Now;

			PropertyAccessor propertyAccessor = 
				new PropertyAccessor(typeof(PropertyAccessorTestObject), "String");
			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				propertyAccessor.Set(testObject, TEST_VALUE);
			}

			DateTime end = DateTime.Now;
			
			TimeSpan time = end - start;
			double propertyAccessorMs = time.TotalMilliseconds;

			//
			// Direct access
			//
			start = DateTime.Now;

			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				testObject.String = TEST_VALUE;
			}

			end = DateTime.Now;
			
			time = end - start;
			double directAccessMs = time.TotalMilliseconds;

			//
			// Reflection
			//
			start = DateTime.Now;
			Type type = testObject.GetType();
			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				type.InvokeMember("String", 
					BindingFlags.Public | BindingFlags.SetProperty | BindingFlags.Instance, 
					null, testObject, new object[]{TEST_VALUE});
			}

			end = DateTime.Now;
			
			time = end - start;
			double reflectionMs = time.TotalMilliseconds;
			
			//
			// Print results
			//
			Console.WriteLine(
				TEST_ITERATIONS.ToString() + " property sets on string..." 
				+ "\nDirect access ms: \t\t\t\t\t" + directAccessMs.ToString()
				+ "\nPropertyAccessor (Reflection.Emit) ms: \t\t" + propertyAccessorMs.ToString() 
				+ "\nReflection ms: \t\t\t\t\t" + reflectionMs.ToString());
		}

#region Private Methods

		private PropertyAccessorTestObject CreateTestObject()
		{
			PropertyAccessorTestObject testObject = new PropertyAccessorTestObject();

			testObject.Int = TEST_INTEGER;
			testObject.String = TEST_STRING;
			testObject.Bool = TEST_BOOL;
			testObject.Byte = TEST_BYTE;
			testObject.Char = TEST_CHAR;
			testObject.DateTime = TEST_DATETIME;
			testObject.Decimal = TEST_DECIMAL;
			testObject.Double = TEST_DOUBLE;
			testObject.Float = TEST_FLOAT;
			testObject.Long = TEST_LONG;
			testObject.Sbyte = TEST_SBYTE;
			testObject.Short = TEST_SHORT;
			testObject.ULong = TEST_ULONG;
			testObject.UShort = TEST_USHORT;
			testObject.List = new ArrayList(TEST_ARRAY);

			return testObject;
		}

#endregion Private Methods
	}
}


--- NEW FILE: FieldAccessorTest.cs ---
//
// Author: James Nies
// Date: 3/22/2005
// Description: This class is a NUnit test for the FieldAccessor class and
//		requires the NUnit framework.
//
// *** This code was written by James Nies and has been provided to you, ***
// *** free of charge, for your use.  I assume no responsibility for any ***
// *** undesired events resulting from the use of this code or the		 ***
// *** information that has been provided with it .						 ***
//
using System;
using System.Collections;
using System.Reflection;


using NUnit.Framework;
using Adapdev.Reflection;

namespace Adapdev.Reflection.Tests
{
	/// <summary>
	/// Test fixture for the FieldAccessor class.
	/// </summary>
	[TestFixture]
	public class FieldAccessorTest
	{

		#region Test Get And Set

		[Test]
		public void TestGetInteger()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mInt");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Int, FieldAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetInteger()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mInt");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			int testInt = 2345;
			FieldAccessor.Set(testObject, testInt);
			Assert.AreEqual(testInt, testObject.Int);			
		}

		[Test]
		public void TestGetString()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mString");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.String, FieldAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetString()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mString");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			string testString = "New string";
			FieldAccessor.Set(testObject, testString);
			Assert.AreEqual(testString, testObject.String);			
		}

		[Test]
		public void TestGetBool()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mBool");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Bool, FieldAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetBool()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mBool");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			bool testBool = true;
			FieldAccessor.Set(testObject, testBool);
			Assert.AreEqual(testBool, testObject.Bool);			
		}

		[Test]
		public void TestGetByte()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mByte");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Byte, FieldAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetByte()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mByte");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			byte testByte = 16;
			FieldAccessor.Set(testObject, testByte);
			Assert.AreEqual(testByte, testObject.Byte);			
		}

		[Test]
		public void TestGetChar()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mChar");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Char, FieldAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetChar()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mChar");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			char testChar = 'Z';
			FieldAccessor.Set(testObject, testChar);
			Assert.AreEqual(testChar, testObject.Char);			
		}

		[Test]
		public void TestGetDateTime()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mDateTime");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.DateTime, FieldAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetDateTime()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mDateTime");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			DateTime testDateTime = DateTime.Now;
			FieldAccessor.Set(testObject, testDateTime);
			Assert.AreEqual(testDateTime, testObject.DateTime);			
		}

		[Test]
		public void TestGetDecimal()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mDecimal");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Decimal, FieldAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetDecimal()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mDecimal");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			decimal testDecimal = new decimal(123123.12);
			FieldAccessor.Set(testObject, testDecimal);
			Assert.AreEqual(testDecimal, testObject.Decimal);			
		}

		[Test]
		public void TestGetDouble()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mDouble");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Double, FieldAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetDouble()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mDouble");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			double testDouble = 9999.99;
			FieldAccessor.Set(testObject, testDouble);
			Assert.AreEqual(testDouble, testObject.Double);			
		}

		[Test]
		public void TestGetFloat()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mFloat");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Float, FieldAccessor.Get(testObject));			
		}
		
		[Test]
		public void TestSetFloat()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mFloat");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			float testFloat = 1982.12F;
			FieldAccessor.Set(testObject, testFloat);
			Assert.AreEqual(testFloat, testObject.Float);			
		}
		
		[Test]
		public void TestGetLong()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mLong");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Long, FieldAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetLong()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mLong");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			long testLong = 92873987232;
			FieldAccessor.Set(testObject, testLong);
			Assert.AreEqual(testLong, testObject.Long);			
		}

		[Test]
		public void TestGetSbyte()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mSbyte");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Sbyte, FieldAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetSbyte()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mSbyte");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			sbyte testSbyte = 19;
			FieldAccessor.Set(testObject, testSbyte);
			Assert.AreEqual(testSbyte, testObject.Sbyte);			
		}

		[Test]
		public void TestGetShort()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mShort");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.Short, FieldAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetShort()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mShort");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			short testShort = 2378;
			FieldAccessor.Set(testObject, testShort);
			Assert.AreEqual(testShort, testObject.Short);			
		}
		
		[Test]
		public void TestGetULong()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mUlong");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.ULong, FieldAccessor.Get(testObject));			
		}

		[Test]
		public void TestSetULong()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mUlong");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			ulong testULong = 29837987298;
			FieldAccessor.Set(testObject, testULong);
			Assert.AreEqual(testULong, testObject.ULong);			
		}
		
		[Test]
		public void TestGetUShort()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mUshort");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.UShort, FieldAccessor.Get(testObject));			
		}
		
		[Test]
		public void TestSetUShort()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mUshort");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			ushort testUShort = 789;
			FieldAccessor.Set(testObject, testUShort);
			Assert.AreEqual(testUShort, testObject.UShort);			
		}

		[Test]
		public void TestGetList()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mList");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			Assert.AreEqual(testObject.List, FieldAccessor.Get(testObject));			
		}
		
		[Test]
		public void TestSetList()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mList");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			ArrayList list = new ArrayList(new int[]{4,5,6});
			FieldAccessor.Set(testObject, list);
			Assert.AreEqual(list, testObject.List);			
		}


		#endregion Test Get And Set

		[Test]
		public void TestTargetType()
		{
			FieldAccessor FieldAccessor
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mInt");

			Assert.AreEqual(typeof(FieldAccessorTestObject),
				FieldAccessor.TargetType);
		}

		[Test]
		public void TestPropertyType()
		{
			FieldAccessor FieldAccessor
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"mInt");

			Assert.AreEqual(typeof(int),
				FieldAccessor.FieldType);
		}

		[Test]
		public void TestCanRead()
		{
			FieldAccessor FieldAccessor;

			//
			// Can read
			//
			FieldAccessor = new FieldAccessor(typeof(FieldAccessorTestObject),
				"mInt");

			Assert.IsTrue(FieldAccessor.CanRead);

			//
			// Cannot read
			//
			FieldAccessor = new FieldAccessor(typeof(FieldAccessorTestObject),
				"mWriteOnlyInt");

			Assert.IsFalse(FieldAccessor.CanRead);
		}

		[Test]
		public void TestCanWrite()
		{
			FieldAccessor FieldAccessor;

			//
			// Can read
			//
			FieldAccessor = new FieldAccessor(typeof(FieldAccessorTestObject),
				"mInt");

			Assert.IsTrue(FieldAccessor.CanWrite);

			//
			// Cannot write
			//
			FieldAccessor = new FieldAccessor(typeof(FieldAccessorTestObject),
				"ReadOnlyInt");

			Assert.IsFalse(FieldAccessor.CanWrite);
		}

		[Test]
		[ExpectedException(typeof(FieldAccessorException),
			 "Property \"ReadOnlyInt\" does not have a set method.")]
		public void TestSetNotSupported()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"ReadOnlyInt");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			//
			// Attempt to set a propert that is read only
			//
			FieldAccessor.Set(testObject, 123);	
		}

		[Test]
		[ExpectedException(typeof(FieldAccessorException),
			 "Field \"WriteOnlyInt\" does not have a get method.")]
		public void TestGetNotSupported()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"WriteOnlyInt");

			FieldAccessorTestObject testObject =
				this.CreateTestObject();

			//
			// Attempt read a write-only property
			//
			int test = (int)FieldAccessor.Get(testObject);	
		}

		[Test]
		[ExpectedException(typeof(FieldAccessorException), 
			 "Field \"NonExistantProperty\" does not exist for "
			 + "type Adapdev.Reflection.Tests.FieldAccessorTestObject.")]
		public void TestNonExistantProperty()
		{
			FieldAccessor FieldAccessor 
				= new FieldAccessor(typeof(FieldAccessorTestObject),
				"NonExistantField");
		}

		[Test]
		public void TestGetIntegerPerformance()
		{
			const int TEST_ITERATIONS = 1000000;

			FieldAccessorTestObject testObject 
				= this.CreateTestObject();

			int test;

			//
			// Property accessor
			//
			DateTime start = DateTime.Now;

			FieldAccessor FieldAccessor = 
				new FieldAccessor(typeof(FieldAccessorTestObject), "Int");
			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				test = (int)FieldAccessor.Get(testObject);
			}

			DateTime end = DateTime.Now;
			
			TimeSpan time = end - start;
			double FieldAccessorMs = time.TotalMilliseconds;

			//
			// Direct access
			//
			start = DateTime.Now;

			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				test = testObject.Int;
			}

			end = DateTime.Now;
			
			time = end - start;
			double directAccessMs = time.TotalMilliseconds;

			//
			// Reflection
			//
			start = DateTime.Now;
			Type type = testObject.GetType();
			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				test = (int)type.InvokeMember("Int", 
					BindingFlags.Public | BindingFlags.GetProperty | BindingFlags.Instance, 
					null, testObject, null);
			}

			end = DateTime.Now;
			
			time = end - start;
			double reflectionMs = time.TotalMilliseconds;
			
			//
			// Print results
			//
			Console.WriteLine(
				TEST_ITERATIONS.ToString() + " property gets on integer..." 
				+ "\nDirect access ms: \t\t\t\t\t" + directAccessMs.ToString()
				+ "\nFieldAccessor (Reflection.Emit) ms: \t\t" + FieldAccessorMs.ToString() 
				+ "\nReflection ms: \t\t\t\t\t" + reflectionMs.ToString());
		}

		[Test]
		public void TestSetIntegerPerformance()
		{
			const int TEST_ITERATIONS = 1000000;
			const int TEST_VALUE = 123;

			FieldAccessorTestObject testObject 
				= this.CreateTestObject();

			//
			// Property accessor
			//
			DateTime start = DateTime.Now;

			FieldAccessor FieldAccessor = 
				new FieldAccessor(typeof(FieldAccessorTestObject), "Int");
			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				FieldAccessor.Set(testObject, TEST_VALUE);
			}

			DateTime end = DateTime.Now;
			
			TimeSpan time = end - start;
			double FieldAccessorMs = time.TotalMilliseconds;

			//
			// Reflection
			//
			start = DateTime.Now;
			Type type = testObject.GetType();
			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				type.InvokeMember("Int", 
					BindingFlags.Public | BindingFlags.SetProperty | BindingFlags.Instance, 
					null, testObject, new object[]{TEST_VALUE});
			}

			end = DateTime.Now;
			
			time = end - start;
			double reflectionMs = time.TotalMilliseconds;
			
			//
			// Print results
			//
			Console.WriteLine(
				TEST_ITERATIONS.ToString() + " property sets on integer..." 
				+ "\nFieldAccessor (Reflection.Emit) ms: \t\t" + FieldAccessorMs.ToString() 
				+ "\nReflection ms: \t\t\t\t\t" + reflectionMs.ToString());
		}

		[Test]
		public void TestGetStringPerformance()
		{
			const int TEST_ITERATIONS = 1000000;

			FieldAccessorTestObject testObject 
				= this.CreateTestObject();

			string test;

			//
			// Property accessor
			//
			DateTime start = DateTime.Now;

			FieldAccessor FieldAccessor = 
				new FieldAccessor(typeof(FieldAccessorTestObject), "String");
			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				test = (string)FieldAccessor.Get(testObject);
			}

			DateTime end = DateTime.Now;
			
			TimeSpan time = end - start;
			double FieldAccessorMs = time.TotalMilliseconds;

			//
			// Direct access
			//
			start = DateTime.Now;

			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				test = testObject.String;
			}

			end = DateTime.Now;
			
			time = end - start;
			double directAccessMs = time.TotalMilliseconds;

			//
			// Reflection
			//
			start = DateTime.Now;
			Type type = testObject.GetType();
			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				test = (string)type.InvokeMember("String", 
					BindingFlags.Public | BindingFlags.GetProperty | BindingFlags.Instance, 
					null, testObject, null);
			}

			end = DateTime.Now;
			
			time = end - start;
			double reflectionMs = time.TotalMilliseconds;
			
			//
			// Print results
			//
			Console.WriteLine(
				TEST_ITERATIONS.ToString() + " property gets on string..." 
				+ "\nDirect access ms: \t\t\t\t\t" + directAccessMs.ToString()
				+ "\nFieldAccessor (Reflection.Emit) ms: \t\t" + FieldAccessorMs.ToString() 
				+ "\nReflection ms: \t\t\t\t\t" + reflectionMs.ToString());
		}

		[Test]
		public void TestSetStringPerformance()
		{
			const int TEST_ITERATIONS = 1000000;
			const string TEST_VALUE = "Test";

			FieldAccessorTestObject testObject 
				= this.CreateTestObject();

			//
			// Property accessor
			//
			DateTime start = DateTime.Now;

			FieldAccessor FieldAccessor = 
				new FieldAccessor(typeof(FieldAccessorTestObject), "String");
			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				FieldAccessor.Set(testObject, TEST_VALUE);
			}

			DateTime end = DateTime.Now;
			
			TimeSpan time = end - start;
			double FieldAccessorMs = time.TotalMilliseconds;

			//
			// Reflection
			//
			start = DateTime.Now;
			Type type = testObject.GetType();
			for(int i = 0; i < TEST_ITERATIONS; i++)
			{
				type.InvokeMember("String", 
					BindingFlags.Public | BindingFlags.SetProperty | BindingFlags.Instance, 
					null, testObject, new object[]{TEST_VALUE});
			}

			end = DateTime.Now;
			
			time = end - start;
			double reflectionMs = time.TotalMilliseconds;
			
			//
			// Print results
			//
			Console.WriteLine(
				TEST_ITERATIONS.ToString() + " property sets on string..." 
				+ "\nFieldAccessor (Reflection.Emit) ms: \t\t" + FieldAccessorMs.ToString() 
				+ "\nReflection ms: \t\t\t\t\t" + reflectionMs.ToString());
		}

		#region Private Methods

		private FieldAccessorTestObject CreateTestObject()
		{
			return new FieldAccessorTestObject();
		}

		#endregion Private Methods
	}
}


--- NEW FILE: PropertyAccessorTestObject.cs ---
//
// Author: James Nies
// Date: 3/22/2005
// Description: Class for testing the PropertyAccessor.
//
// *** This code was written by James Nies and has been provided to you, ***
// *** free of charge, for your use.  I assume no responsibility for any ***
// *** undesired events resulting from the use of this code or the		 ***
// *** information that has been provided with it .						 ***
//

using System;
using System.Collections;

namespace Adapdev.Reflection.Tests
{
	/// <summary>
	/// PropertyAccessorTestObject.
	/// </summary>
	public class PropertyAccessorTestObject
	{
		public PropertyAccessorTestObject()
		{
		}

		public int Int
		{
			get
			{
				return this.mInt;
			}
			set
			{
				this.mInt = value;
			}
		}

		public string String
		{
			get
			{
				return this.mString;
			}
			set
			{	
				this.mString = value;
			}
		}

		public sbyte Sbyte
		{
			get
			{
				return this.mSbyte;
			}
			set
			{
				this.mSbyte = value;
			}
		}

		public byte Byte
		{
			get
			{
				return this.mByte;
			}
			set
			{
				this.mByte = value;
			}
		}

		public char Char
		{
			get
			{
				return this.mChar;
			}
			set
			{
				this.mChar = value;
			}
		}

		public short Short
		{
			get
			{
				return this.mShort;
			}
			set
			{
				this.mShort = value;
			}
		}

		public ushort UShort
		{
			get
			{
				return this.mUshort;
			}
			set
			{
				this.mUshort = value;
			}
		}

		public long Long
		{
			get
			{
				return this.mLong;
			}
			set
			{
				this.mLong = value;
			}
		}

		public ulong ULong
		{
			get
			{
				return this.mUlong;
			}
			set
			{
				this.mUlong = value;
			}
		}

		public bool Bool
		{
			get
			{
				return this.mBool;
			}
			set
			{
				this.mBool = value;
			}
		}

		public double Double
		{
			get
			{
				return this.mDouble;
			}
			set
			{
				this.mDouble = value;
			}
		}

		public float Float
		{
			get
			{
				return this.mFloat;
			}
			set
			{
				this.mFloat = value;
			}
		}

		public DateTime DateTime
		{
			get
			{
				return this.mDateTime;
			}
			set
			{
				this.mDateTime = value;
			}
		}

		public decimal Decimal
		{
			get
			{
				return this.mDecimal;
			}
			set
			{
				this.mDecimal = value;
			}
		}

		public IList List
		{
			get
			{
				return this.mList;
			}
			set
			{
				this.mList = value;
			}
		}

		public int ReadOnlyInt
		{
			get
			{
				return this.mReadOnlyInt;
			}
		}

		public int WriteOnlyInt
		{
			set
			{
				this.mWriteOnlyInt = value;	
			}
		}

		private int mInt;
		private string mString;
		private sbyte mSbyte;
		private byte mByte;
		private char mChar;
		private short mShort;
		private ushort mUshort;
		private long mLong;
		private ulong mUlong;
		private bool mBool;
		private double mDouble;
		private float mFloat;
		private DateTime mDateTime;
		private decimal mDecimal;
		private IList mList;
		private int mReadOnlyInt = 0;
		private int mWriteOnlyInt;
	}
}

--- NEW FILE: ClassAccessorTest.cs ---
using System;
using NUnit.Framework;
using Adapdev.Reflection;

namespace Adapdev.Reflection.Tests
{
	/// <summary>
	/// Summary description for IValidatable.
	/// </summary>
	/// 
	[TestFixture]
	public class ClassAccessorTest
	{
		[Test]
		public void SetAndGet()
		{
			PropertyAccessorTestObject o = new PropertyAccessorTestObject();
			ClassAccessor c = new ClassAccessor(o);

			c.SetPropertyValue(o, "Bool", false);
			c.SetPropertyValue(o, "Int", 3);
			int i = (int)c.GetPropertyValue(o, "Int");
			bool b = (bool)c.GetPropertyValue(o, "Bool");

			Assert.AreEqual(3, o.Int, "Int should be 3.");
			Assert.AreEqual(false, o.Bool, "Bool should be false.");

			Assert.AreEqual(3, i, "Returned Int should be 3.");
			Assert.AreEqual(false, b, "Returned Bool should be false.");

		}

		[Test]
		public void LoadAllProperties()
		{
			PropertyAccessorTestObject o = new PropertyAccessorTestObject();
			ClassAccessor c = new ClassAccessor(o);
			c.LoadAllProperties();
			Console.WriteLine(c);
			Assert.AreEqual(17, c.PropertyCount, "Should have loaded 17 properties.");
		}
	}

}