UnitTest.cs

Go to the documentation of this file.

using System;
using System.Diagnostics;
using System.Reflection;

namespace FFT.Test {
   using FFT;

   ///
   /// Unit testing facility
   ///
   /// Every unit test class should extend UnitTest. The method UnitTest::Test() 
   /// should be implemented.  The static method UnitTest::RunTests() finds all classes
   /// in the caller assembly that extend UnitTest, and for each one, it 
   /// creates an instance and runs the test. Inside UnitTest::Test() the methods 
   /// UnitTest::AssertEq<T> and UnitTest::AssertNearEq should be used 
   /// to test the expected behavior of specific components of the system.  
   /// Then, if the test fails, the global counter ::FailedCount will be incremented 
   /// automatically.
   ///
   public abstract class UnitTest {
      
      ///
      /// Main entry point of a test. 
      ///
      public abstract void Test();

      ///
      /// The name of the test suite.
      ///
      /// The standard definition removes the string <tt>"Test"</tt> from 
      /// the class name. For instance, if <tt>ABTestCDTest</tt> 
      /// extends UnitTest, then this method will return <tt>"ABCD"</tt>.
      public override string ToString()
      {
         return this.GetType().Name.Replace("Test",null);
      }

      ///
      /// The number of failed assertions. 
      /// 
      protected static int FailedCount;

      ///
      /// Checks the equality of two values. 
      /// 
      /// The method prints the message <tt>msg</tt> and indication of the
      /// result of the comparison. If the result is negative (i.e. the values are 
      /// different), then it automatically increases the value of ::FailedCount.
      ///
      /// \param result the result of a test
      /// \param goal the expected result of a test
      /// \param msg the name of the test
      ///
      public static void AssertEq<T>(T result, T goal, string msg) where T : IEquatable<T> {
         Console.Write( "   " + msg );
         if ( result.Equals(goal)) {
            Console.Write("...OK\n");
         } else {
            FailedCount++;
            Console.Write("...FAILED!\n");
            Console.Write("      Expected: {0}\n",goal);
            Console.Write("      Have:     {0}\n",result);
         }
      }

      ///
      /// \copydoc ::AssertEq<T>(T,T,string) 
      ///
      /// This method checks that both arrays have the same value and 
      /// that the corresponding elements have the same value. 
      ///
      public static void AssertEq<T>(T[] result, T[] goal, string msg) 
         where T : IEquatable<T> 
      {
         Console.Write("   " + msg);
         
         if (result.Length != goal.Length) {
            FailedCount++;
            Console.Write("...FAILED!\n");
            Console.Write("      Expected length: {0}\n",goal.Length);
            Console.Write("      Have length:     {0}\n",result.Length);
            return ;
         }

         bool equal = true;
         int i = 0;
         while (equal && i < result.Length) {
            equal = result[i].Equals(goal[i]);
            i++;
         }

         if (equal) {
            Console.Write("...OK\n");
         } else {
            FailedCount++;
            Console.Write("...FAILED!\n");
            Console.Write("      Position: {0}\n",--i);
            Console.Write("      Expected: {0}\n",goal[i]);
            Console.Write("      Have:     {0}\n",result[i]);
         }
      }

      ///
      /// Maximal absolute difference between two nearly equal values. 
      ///
      public static double Precision = 1E-10;

      ///
      /// \copydoc ::AssertEq<T>(T,T,string)
      ///
      /// This method checks that both arrays have the same length and 
      /// that the corresponding elements are nearly equal (see ::Precision). 
      ///
      public static void AssertNearEq(Complex[] result, Complex[] goal, string msg) 
      {
         Console.Write("   " + msg);
         
         if (result.Length != goal.Length) {
            FailedCount++;
            Console.Write("...FAILED!\n");
            Console.Write("      Expected length: {0}\n",goal.Length);
            Console.Write("      Have length:     {0}\n",result.Length);
            //Utils.PrintArray(goal  ,"Expected:");
            //Utils.PrintArray(result,"Have    :");
            return;
         }

         bool equal = true;
         int i = 0;
         while (equal && i < result.Length) {
            equal = (result[i]-goal[i]).Modulus < Precision;
            i++;
         }

         if (equal) {
            Console.Write("...OK\n");
         } else {
            FailedCount++;
            Console.Write("...FAILED!\n");
            Console.Write("      Position: {0}\n",--i);
            Console.Write("      Expected: {0}\n",goal[i]);
            Console.Write("      Have:     {0}\n",result[i]);
            //Utils.PrintArray(goal  ,"Expected:");
            //Utils.PrintArray(result,"Have    :");
         }
      }
      
      /// 
      /// Runs all the tests. 
      /// 
      /// Dynamically searches the current assembly for all classes extending 
      /// UniteTest and runs the tests on the instances.
      ///
      public static void RunTests()
      {
         Assembly assembly = Assembly.GetCallingAssembly();

         FailedCount = 0;
         foreach (Type t in assembly.GetTypes()) {
            if (t.IsSubclassOf(Type.GetType("FFT.Test.UnitTest"))) {
               ConstructorInfo c = t.GetConstructor(new Type[0]);
               UnitTest unit = (UnitTest) c.Invoke(new object[0]);

               Console.Write("-----------------------------------------------\n" +
                             "  Test suite: {0}\n" +
                             "-----------------------------------------------\n",
                             unit.ToString());
               unit.Test();
            }
         }

         if (FailedCount != 0) {
            Console.Write("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"+
                          "          TOTAL FAILED COUNT: {0} \n" +
                          "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n",
                          FailedCount);
         }
      }

      
   }
}

---