// The following code was generated by Microsoft Visual Studio 2005.

// The test owner should check each test for validity.

using Microsoft.VisualStudio.TestTools.UnitTesting;

using System;

using System.Text;

using System.Collections.Generic;

using CBucks;



namespace FunctionsTests {

	/// <summary>

	///This is a test class for CBucks.TotalDomain&lt;TR&gt; and is intended

	///to contain all CBucks.TotalDomain&lt;TR&gt; Unit Tests

	///</summary>

	[TestClass()]

	public class TotalDomainTest {





		private TestContext testContextInstance;



		/// <summary>

		///Gets or sets the test context which provides

		///information about and functionality for the current test run.

		///</summary>

		public TestContext TestContext {

			get {

				return testContextInstance;

			}

			set {

				testContextInstance = value;

			}

		}



		#region Total functions used for testing



		private static TotalDomain<int> itd;

		private static TotalDomain<bool> btd;

		private static TotalDomain<float> ftd;

		private static TotalDomain<object> otd;

		private static Span1D sp;



		#endregion Total functions used for testing



		#region Additional test attributes

		

		[ClassInitialize()]

		public static void MyClassInitialize(TestContext testContext) {

			itd = (TotalDomain<int>)PureFunc.createTotalDomain(typeof(int));

			btd = (TotalDomain<bool>)PureFunc.createTotalDomain(typeof(bool));

			ftd = (TotalDomain<float>)PureFunc.createTotalDomain(typeof(float));

			otd = (TotalDomain<object>)PureFunc.createTotalDomain(typeof(object));

			sp = (Span1D)Span1D.create(-5, 5);

		}



		

		#endregion





		/// <summary>

		///A test for card

		///</summary>

		[TestMethod()]

		[ExpectedException(typeof(InfiniteDomainException), 

			"Cardinality of infinite domain function cannot be obtained")]

		public void cardTest() {

			int c = itd.card;

		}



		/// <summary>

		///A test for card

		///</summary>

		[TestMethod()]

		public void cardTest2() {

			Assert.AreEqual(2, btd.card, "Cardinality of total functions on finite " +

				"types equals to cardinality of that type");

		}



		/// <summary>

		///A test for clamp (TR)

		///</summary>

		[TestMethod()]

		public void clampTest() {

			Assert.AreEqual(10.0f, ftd.clamp(10.0f), "Clamping with a total function returns the " +

				"same value");

		}



		/// <summary>

		///A test for Equals (object)

		///</summary>

		[TestMethod()]

		public void EqualsTest() {

			Assert.AreEqual(itd, PureFunc.createTotalDomain(typeof(int)),

				"Total domains of the same type are equal");

		}



		/// <summary>

		///A test for Equals (object)

		///</summary>

		[TestMethod()]

		public void EqualsTest2() {

			Assert.AreNotEqual(itd, otd, 

				"Total domains of different types are not equal");

		}



		/// <summary>

		///A test for Equals (object)

		///</summary>

		[TestMethod()]

		public void EqualsTest3() {

			Assert.AreNotEqual(itd, sp,

				"Total domains are not equal to functions of different classes");

		}



		/// <summary>

		///A test for equiv (IPureFunction)

		///</summary>

		[TestMethod()]

		public void equivTest() {

			Assert.IsTrue(TotalDomain<int>.equiv(itd, PureFunc.createTotalDomain(typeof(int))),

				"Total domains of the same type are equivalent");

		}



		/// <summary>

		///A test for equiv (IPureFunction)

		///</summary>

		[TestMethod()]

		public void equivTest2() {

			Assert.IsFalse(TotalDomain<int>.equiv(itd, otd),

				"Total domains of different types are not equivalent");

		}



		/// <summary>

		///A test for equiv (IPureFunction)

		///</summary>

		[TestMethod()]

		public void equivTest3() {

			Assert.IsFalse(TotalDomain<int>.equiv(itd, sp),

				"Total domains are generally not equivalent to functions of different " + 

				"classes ");

		}



		//TODO: add equivalence test of boolean total vs. boolean array





		/// <summary>

		///A test for eval (int)

		///</summary>

		[TestMethod()]

		[ExpectedException(typeof(NotEvaluatableException), "Non-finite total " + 

			"functions cannot be evaluated")]

		public void evalTest() {

			ftd.eval(0);

		}



		[TestMethod()]

		public void evalTest2() {

			Assert.AreEqual(10, itd.eval(10), "Integer total function can be evaluated");

		}



		[TestMethod()]

		public void evalTest3() {

			Assert.AreEqual(true, btd.eval(1), "Finite-type total function can be evaluated");

		}



		/// <summary>

		///A test for first

		///</summary>

		[TestMethod()]

		[ExpectedException(typeof(InfiniteDomainException), "Non-finite total " + 

			"has its first element unevaluatable")]

		public void firstTest() {

			float f = ftd.first;

		}



		/// FINISHED CODING HERE

		/// <summary>

		///</summary>

		[TestMethod()]

		public void GetHashCodeTest() {

			Assert.AreEqual(itd.GetHashCode(),

				((TotalDomain<int>)PureFunc.createTotalDomain(typeof(int))).GetHashCode());

		}



		/// <summary>

		///A test for includes (TotalDomain&lt;TR&gt;, IPureFunction)

		///</summary>

		[TestMethod()]

		public void includesTest() {

			Assert.IsTrue(TotalDomain<int>.includes(itd, sp));

		}



		/// <summary>

		///A test for includes (TotalDomain&lt;TR&gt;, IPureFunction)

		///</summary>

		[TestMethod()]

		[ExpectedException(typeof(TypeMismatchException), "Inclusion not valid on " +

			"functions of different types")]

		public void includesTest2() {

			bool b = TotalDomain<int>.includes(itd, ftd);

		}



		/// <summary>

		///A test for inters (TotalDomain&lt;TR&gt;, IPureFunction)

		///</summary>

		[TestMethod()]

		public void intersTest() {

			Assert.AreEqual(sp, TotalDomain<int>.inters(itd, sp));

		}



		/// <summary>

		///A test for isFinite

		///</summary>

		[TestMethod()]

		public void isFiniteTest() {

			Assert.IsTrue(btd.isFinite, "Finite function total domains are finite");

		}



		/// <summary>

		///A test for isFinite

		///</summary>

		[TestMethod()]

		public void isFiniteTest2() {

			Assert.IsFalse(ftd.isFinite, "Infinite function total domains are non-finite");

		}



		/// <summary>

		///A test for isin (TR)

		///</summary>

		[TestMethod()]

		public void isinTest() {

			Assert.IsTrue(itd.isin(5), "Total functions include all type values");

		}



		/// <summary>

		///A test for last

		///</summary>

		[TestMethod()]

		[ExpectedException(typeof(InfiniteDomainException), "Non-finite type total " +

			"functions are do not have last elements")]

		public void lastTest() {

			int last = itd.last;

		}



		/// <summary>

		///A test for last for finite types

		///</summary>

		[TestMethod()]

		public void lastTest2() {

			bool last = btd.last;

			Assert.IsTrue(last);

		}



		/// <summary>

		///A test for project (params int[])

		///</summary>

		[TestMethod()]

		public void projectTest() {

			IPureFunction ipf = itd.project(0);

			Assert.AreEqual(ipf, itd, "Projection of non-tuple total functions to " +

				"its only dimension must give the same function");

		}



		/// <summary>

		///A test for project (params int[])

		///</summary>

		[TestMethod()]

		[ExpectedException(typeof(CBucks.RankException), "Projection to index " +

			"which exceeds rank raises the rank exception")]

		public void projectTest2() {

			IPureFunction ipf = itd.project(1);

		}



		/// <summary>

		///A test for project (params int[])

		///</summary>

		[TestMethod()]

		public void projectTest3() {

			IPureFunction isf = PureFunc.createTotalDomain(typeof(Tuple02<int, float>));

			IPureFunction ipf = isf.project(1);

			Assert.AreEqual(ipf, ftd, "Projection of tuple total functions to " +

				"a dimension must give the total function");

		}



		/// <summary>

		///A test for pseudoInvert

		///</summary>

		[TestMethod()]

		[Ignore()]

		public void pseudoInvertTest() {

			Assert.Inconclusive("Generics testing must be manually provided.");

		}



		/// <summary>

		///A test for range

		///</summary>

		[TestMethod()]

		public void rangeTest() {

			Assert.AreSame(otd.range, otd, "A range of total function is the function itself");

		}



		/// <summary>

		///A test for rid

		///</summary>

		[TestMethod()]

		[Ignore]

		public void ridTest() {

			Assert.Inconclusive("Generics testing must be manually provided.");

		}



		/// <summary>

		///A test for ToString ()

		///</summary>

		[TestMethod()]

		public void ToStringTest() {

			Assert.AreEqual("total", otd.ToString());

		}



		/// <summary>

		///A test for trueInvert

		///</summary>

		[TestMethod()]

		[Ignore]

		public void trueInvertTest() {

			Assert.Inconclusive("Generics testing must be manually provided.");

		}



		/// <summary>

		///A test for union (TotalDomain&lt;TR&gt;, IPureFunction)

		///</summary>

		[TestMethod()]

		public void unionTest() {

			Assert.AreEqual(itd, TotalDomain<int>.union(itd, sp));

		}



		/// <summary>

		///A test for values

		///</summary>

		[TestMethod()]

		[ExpectedException(typeof(InfiniteDomainException), "Values of an " +

			"infinite-domain function cannot be iterated through")]

		public void valuesTest() {

			int j = 0;

			foreach(int i in itd.values) j++;

		}



		/// <summary>

		///A test for values

		///</summary>

		[TestMethod()]

		public void valuesTest2() {

			int j = 0;

			foreach(bool b in btd.values)

				if(j++ == 0)

					Assert.IsFalse(b);

				else

					Assert.IsTrue(b);

		}



	}





}