Working with Units and Amounts

using System;
using System.Text;
using System.Collections.Generic;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using TypedUnits;
using StandardUnits;

namespace TestProject
{
    /// <summary>
    /// Summary description for PerformanceTests
    /// </summary>
    [TestClass]
    [Ignore]
    public class UnitPerformanceTests
    {
        const double MAX_ACCEPTABLE_VARIANCE = +0.25;
        const double MIN_ACCEPTABLE_VARIANCE = -0.25;

        #region Initialize & cleanup

        private UnitManager defaultUnitManager;

        [TestInitialize()]
        public void MyTestInitialize()
        {
            Console.Write("Resetting the UnitManager instance...");
            this.defaultUnitManager = UnitManager.Instance;
            UnitManager.Instance = new UnitManager();
            UnitManager.RegisterByAssembly(typeof(LengthUnits).Assembly);
            Console.WriteLine(" done.");
        }

        [TestCleanup()]
        public void MyTestCleanup()
        {
            UnitManager.Instance = this.defaultUnitManager;
        }

        #endregion Initialize & cleanup

        [TestMethod]
        public void AmountAdditionPerformanceTest()
        {
            Amount a = new Amount(15.0, LengthUnits.Meter);
            Amount sum = new Amount(0.0, LengthUnits.Meter);


            long t = Environment.TickCount;
            for (int n = 0; n < 100000; n++)
            {
                sum += a;
            }
            double time = (Environment.TickCount - t) / 1000.0;
            double var = (time - 0.031) / 0.031;

            Console.WriteLine("Time to perform 100K additions: {0} sec.", time);
            Console.WriteLine("Variation: {0:0}%.", var*100);

            Assert.AreEqual(1500000.0, sum.Value);
            
            Assert.IsTrue(var < MAX_ACCEPTABLE_VARIANCE, "Performance lost detected!");
            //if (var < MIN_ACCEPTABLE_VARIANCE) Assert.Inconclusive("Performance was much better than expected.");
        }

        [TestMethod]
        public void AmountDerivedAdditionPerformanceTest()
        {
            Amount sum = new Amount(0.0, LengthUnits.KiloMeter);


            long t = Environment.TickCount;
            for (int n = 0; n < 100000; n++)
            {
                sum += new Amount(15.0, LengthUnits.Meter);
            }
            double time = (Environment.TickCount - t) / 1000.0;
            double var = (time - 0.219) / 0.219;

            Console.WriteLine("Sum = {0}", sum);
            Console.WriteLine("Time to perform 100K additions: {0} sec.", time);
            Console.WriteLine("Variation: {0:0}%.", var*100);

            Assert.AreEqual(1500.0, Math.Round(sum.Value, 8));

            Assert.IsTrue(var < MAX_ACCEPTABLE_VARIANCE, "Performance lost detected!");
            if (var < MIN_ACCEPTABLE_VARIANCE) Assert.Inconclusive("Performance was much better than expected.");
        }

        [TestMethod]
        public void AmountSimpleDivisionPerformanceTest()
        {
            Amount a = new Amount(15.0, LengthUnits.Meter);
            Amount b = new Amount(3.0, TimeUnits.Second);
            Amount q = null;

            long t = Environment.TickCount;
            for (int n = 0; n < 100000; n++)
            {
                q = a / b;
            }
            double time = (Environment.TickCount - t) / 1000.0;
            double var = (time - 0.11) / 0.11;

            Console.WriteLine("Time to perform 100K simple divisions: {0} sec.", time);
            Console.WriteLine("Variation: {0:0}%.", var * 100);

            Assert.AreEqual(5.0, q.Value);
            Assert.IsTrue(q.Unit.IsCompatibleTo(LengthUnits.Meter / TimeUnits.Second));

            Assert.IsTrue(var < MAX_ACCEPTABLE_VARIANCE, "Performance lost detected!");
            if (var < MIN_ACCEPTABLE_VARIANCE) Assert.Inconclusive("Performance was much better than expected.");
        }

        [TestMethod]
        public void AmountComplexDivisionPerformanceTest()
        {
            Amount a = new Amount(15.0, LengthUnits.KiloMeter);
            Amount b = new Amount(3.0, TimeUnits.Hour);
            Amount q = null;

            long t = Environment.TickCount;
            for (int n = 0; n < 100000; n++)
            {
                q = a / b;
            }
            double time = (Environment.TickCount - t) / 1000.0;
            double var = (time - 0.11) / 0.11;
            
            Console.WriteLine("Time to perform 100K complex divisions: {0} sec.", time);
            Console.WriteLine("Variation: {0:0}%.", var * 100);

            Assert.AreEqual(5.0, q.Value);
            Assert.AreEqual(5.0, q.ConvertedTo(LengthUnits.KiloMeter / TimeUnits.Hour, 8).Value);
            Assert.IsTrue(q.Unit.IsCompatibleTo(LengthUnits.Meter / TimeUnits.Second));

            Assert.IsTrue(var < MAX_ACCEPTABLE_VARIANCE, "Performance lost detected!");
            if (var < MIN_ACCEPTABLE_VARIANCE) Assert.Inconclusive("Performance was much better than expected.");
        }

        [TestMethod]
        public void AmountScenario01PerformanceTest()
        {
            Amount distance;
            Amount speed;
            Amount duration = Amount.Zero(TimeUnits.Day);

            long t = Environment.TickCount;
            for (int n = 1; n <= 10000; n++)
            {
                distance = new Amount(50.0, new Unit("myfoot", "myft", 44.0 * LengthUnits.CentiMeter));
                speed = new Amount(n, LengthUnits.KiloMeter / TimeUnits.Hour);
                duration += distance / speed;
            }
            double time = (Environment.TickCount - t) / 1000.0;
            double var = (time - 0.234) / 0.234;

            duration = duration.ConvertedTo(TimeUnits.Minute, 1);
            
            Console.WriteLine("Time to perform 10K complex scenario: {0} sec.", time);
            Console.WriteLine("Variation: {0:0}%.", var * 100);

            Assert.AreEqual(12.9, duration.Value);
            Assert.IsTrue(duration.Unit.IsCompatibleTo(TimeUnits.Second));

            Assert.IsTrue(var < MAX_ACCEPTABLE_VARIANCE, "Performance lost detected!");
            if (var < MIN_ACCEPTABLE_VARIANCE) Assert.Inconclusive("Performance was much better than expected.");
        }

        [TestMethod]
        public void AmountSimpleConvertPerformanceTest()
        {
            Amount a = new Amount(15.0, LengthUnits.KiloMeter);
            Amount b = null;

            long t = Environment.TickCount;
            for (int n = 0; n < 100000; n++)
            {
                b = a.ConvertedTo(LengthUnits.Meter, 8);
            }
            double time = (Environment.TickCount - t) / 1000.0;
            double var = (time - 0.172) / 0.172;

            Console.WriteLine("Result = {0}", b);
            Console.WriteLine("Time to perform 100K convertions: {0} sec.", time);
            Console.WriteLine("Variation: {0:0}%.", var * 100);

            Assert.AreEqual(15000, b.Value);

            Assert.IsTrue(var < MAX_ACCEPTABLE_VARIANCE, "Performance lost detected!");
            if (var < MIN_ACCEPTABLE_VARIANCE) Assert.Inconclusive("Performance was much better than expected.");
        }

        [TestMethod]
        public void AmountComplexConvertPerformanceTest()
        {
            Amount a = new Amount(15.0, (LengthUnits.KiloMeter * LengthUnits.Meter / LengthUnits.MilliMeter / (TimeUnits.Hour * TimeUnits.Minute / TimeUnits.MilliSecond)));
            Amount b = null;
            Unit targetUnit = LengthUnits.Meter / TimeUnits.Second;

            long t = Environment.TickCount;
            for (int n = 0; n < 100000; n++)
            {
                b = a.ConvertedTo(targetUnit, 8);
            }
            double time = (Environment.TickCount - t) / 1000.0;
            double var = (time - 0.203) / 0.203;

            Console.WriteLine("Original = {0}", a);
            Console.WriteLine("Result = {0}", b);
            Console.WriteLine("Time to perform 100K convertions: {0} sec.", time);
            Console.WriteLine("Variation: {0:0}%.", var * 100);

            Assert.AreEqual(0.06944444, b.Value);

            Assert.IsTrue(var < MAX_ACCEPTABLE_VARIANCE, "Performance lost detected!");
            if (var < MIN_ACCEPTABLE_VARIANCE) Assert.Inconclusive("Performance was much better than expected.");
        }

        [TestMethod]
        public void UnitManagerResolveNamedToNamedTest()
        {
            // Try resolving a named unit:

            Unit u = LengthUnits.KiloMeter;
            Unit v = null;

            long t = Environment.TickCount;
            for (int n = 0; n < 100000; n++)
            {
                v = UnitManager.ResolveToNamedUnit(u, true);
            }
            double time = (Environment.TickCount - t) / 1000.0;
            double var = (time - 0.015) / 0.015;

            Console.WriteLine("Original = {0}", u.Name);
            Console.WriteLine("Result = {0}", v.Name);
            Console.WriteLine("Time to perform 100K resolutions: {0} sec.", time);
            Console.WriteLine("Variation: {0:0}%.", var * 100);

            Assert.IsTrue(v.IsNamed);
            Assert.AreEqual("kilometer", v.Name);

            Assert.IsTrue(var < MAX_ACCEPTABLE_VARIANCE, "Performance lost detected!");
            if (var < MIN_ACCEPTABLE_VARIANCE) Assert.Inconclusive("Performance was much better than expected.");
        }

        [TestMethod]
        public void UnitManagerResolveKnownToNamedTest()
        {
            // Try resolving a known unit:

            Unit u = LengthUnits.Meter / TimeUnits.Second;
            Unit v = null;

            long t = Environment.TickCount;
            for (int n = 0; n < 100000; n++)
            {
                v = UnitManager.ResolveToNamedUnit(u, true);
            }
            double time = (Environment.TickCount - t) / 1000.0;
            double var = (time - 0.219) / 0.219;

            Console.WriteLine("Original = {0}", u.Name);
            Console.WriteLine("Result = {0}", v.Name);
            Console.WriteLine("Time to perform 100K resolutions: {0} sec.", time);
            Console.WriteLine("Variation: {0:0}%.", var * 100);

            Assert.IsTrue(v.IsNamed);
            Assert.AreEqual("meter/second", v.Name);

            Assert.IsTrue(var < MAX_ACCEPTABLE_VARIANCE, "Performance lost detected!");
            if (var < MIN_ACCEPTABLE_VARIANCE) Assert.Inconclusive("Performance was much better than expected.");
        }

        [TestMethod]
        public void UnitManagerResolveUnknownToNamedTest()
        {
            // Try resolving an unknown unit of a known family:

            Unit u = LengthUnits.NauticalMile / TimeUnits.Minute;
            Unit v = null;

            long t = Environment.TickCount;
            for (int n = 0; n < 100000; n++)
            {
                v = UnitManager.ResolveToNamedUnit(u, true);
            }
            double time = (Environment.TickCount - t) / 1000.0;
            double var = (time - 0.297) / 0.297;

            Console.WriteLine("Original = {0}", u.Name);
            Console.WriteLine("Result = {0}", v.Name);
            Console.WriteLine("Time to perform 100K resolutions: {0} sec.", time);
            Console.WriteLine("Variation: {0:0}%.", var * 100);

            Assert.IsFalse(v.IsNamed);

            Assert.IsTrue(var < MAX_ACCEPTABLE_VARIANCE, "Performance lost detected!");
            if (var < MIN_ACCEPTABLE_VARIANCE) Assert.Inconclusive("Performance was much better than expected.");
        }

        [TestMethod]
        public void UnitManagerResolveUnfamiliarToNamedTest()
        {
            // Try resolving a unit of an unknown family:

            Unit u = LengthUnits.Meter * ElectricUnits.Ohm;
            Unit v = null;

            long t = Environment.TickCount;
            for (int n = 0; n < 100000; n++)
            {
                v = UnitManager.ResolveToNamedUnit(u, true);
            }
            double time = (Environment.TickCount - t) / 1000.0;
            double var = (time - 0.032) / 0.032;

            Console.WriteLine("Original = {0}", u.Name);
            Console.WriteLine("Result = {0}", v.Name);
            Console.WriteLine("Time to perform 100K resolutions: {0} sec.", time);
            Console.WriteLine("Variation: {0:0}%.", var * 100);

            Assert.IsFalse(v.IsNamed);

            Assert.IsTrue(var < MAX_ACCEPTABLE_VARIANCE, "Performance lost detected!");
            if (var < MIN_ACCEPTABLE_VARIANCE) Assert.Inconclusive("Performance was much better than expected.");
        }
    }
}