public void Performance_RunningSummedIntervals_1()
 {
     DateTime startTime = DateTime.Now;
     Tnum t = new Tnum(9.99).RunningSummedIntervals(TheDay);
     int ResponseTimeInMs = Convert.ToInt32((DateTime.Now - startTime).TotalMilliseconds);
     Assert.IsTrue(ResponseTimeInMs < 85);
 }

 public void ElapsedDaysPerInterval_5()
 {
     Tbool t = new Tbool(false);
     Tnum n = new Tnum(Hstate.Unstated);
     Tnum result = t.TotalElapsedDaysPer(n);
     Assert.AreEqual("Unstated", result.Out);
 }

 public void Misc_TemporalRecursion4()
 {
     Tnum x = new Tnum();
     x.AddState(Time.DawnOf, 10);
     x.AddState(new DateTime(2000,1,1), 1);
     Assert.AreEqual("{Dawn: 89; 1/1/2000: 1}", TemporalFibonacci(x).Out);
 }

        public void HasUndefinedIntervals1()
        {
            Tnum r = new Tnum(new Hval(null,Hstate.Null));
            r.AddState(Date(2000,1,1), new Hval(null,Hstate.Unstated));
            r.AddState(Date(2001,1,1), 2);

            Assert.AreEqual(true, Util.HasUndefinedIntervals(r));
        }

 public void RunningSummedIntervals_1()
 {
     Tnum t = new Tnum(0);
     t.AddState(Date(2012, 1, 1), 1000);
     t.AddState(Date(2012, 3, 1), 0);
     Tnum r = t.RunningSummedIntervals(TheMonth);
     Assert.AreEqual("{Dawn: 0; 2/1/2012: 1000; 3/1/2012: 2000}", r.Out);
 }

        public void AssignAndMerge1()
        {
            Tbool newCondition = new Tbool(Hstate.Uncertain);
            Tnum initialResult = new Tnum(Hstate.Null);
            Tbool newConditionIsUnknown = new Tbool(true);

            Tnum result = Util.MergeTvars<Tnum>(initialResult,
                                         Util.ConditionalAssignment<Tnum>(newConditionIsUnknown, newCondition));

            Assert.AreEqual("Uncertain", result.Out);
        }

        public void AssignAndMerge2()
        {
            Tbool newCondition = new Tbool(Hstate.Uncertain);
            Tnum initialResult = new Tnum(Hstate.Null);
            Tbool newConditionIsUnknown = new Tbool(true);

            Tnum result = Util.MergeTvars<Tnum>(initialResult,
                                         Util.ConditionalAssignment<Tnum>(newConditionIsUnknown, newCondition));

            Assert.AreEqual(false, Util.HasUndefinedIntervals(result));
        }

 public void RunningSummedIntervals_3()
 {
     Tnum t = new Tnum(Hstate.Unstated);
     Tnum r = t.RunningSummedIntervals(TheMonth);
     Assert.AreEqual("Unstated", r.Out);
 }

 public void RunningSummedIntervals_2()
 {
     Tnum t = new Tnum(0);
     Tnum r = t.RunningSummedIntervals(TheMonth);
     Assert.AreEqual(0, r.Out);
 }

 public void Up3()
 {
     Tnum res = new Tnum(7.33).RoundUp(0.25);
     Assert.AreEqual(7.50, res.Out);
 }

 public void TotalSummedIntervals_5()
 {
     Tnum t = new Tnum(1000);
     t.AddState(Date(2015, 6, 1), 2000);
     Tnum r = t.TotalSummedIntervals(TheMonth, Date(2015,1,1), Date(2016,1,1));
     Assert.AreEqual(19000, r.Out);
 }

 public void Up5()
 {
     Tnum res = new Tnum(1324103).RoundUp(50000);
     Assert.AreEqual(1350000, res.Out);
 }

 public void SlidingSummedIntervals_3()
 {
     Tnum t = new Tnum(Hstate.Stub);
     Tnum r = t.SlidingSummedIntervals(TheMonth, 2);
     Assert.AreEqual("Stub", r.Out);
 }

 public void SlidingSummedIntervals_1()
 {
     Tnum t = new Tnum(1000);
     Tnum r = t.SlidingSummedIntervals(TheMonth, 2);
     Assert.AreEqual(2000, r.Out);
 }

 public void SlidingSummedIntervals_4()
 {
     Tnum t = new Tnum(1000);
     t.AddState(Date(2013, 1, 1), 2000);
     Tnum r = t.SlidingSummedIntervals(TheYear, 2);
     Assert.AreEqual("{Dawn: 2000; 1/1/2014: 3000; 1/1/2015: 4000}", r.Out);
 }

 public void Near3()
 {
     Tnum res = new Tnum(125).RoundToNearest(10);
     Assert.AreEqual(130, res.Out);
 }

 public void Near10()
 {
     Tnum res = new Tnum(88.34).RoundToNearest(1);
     Assert.AreEqual(88.00, res.Out);
 }

 public void Down5()
 {
     Tnum res = new Tnum(0).RoundDown(1);
     Assert.AreEqual(0, res.Out);
 }

 public void Down4()
 {
     Tnum res = new Tnum(1324103).RoundDown(50000);
     Assert.AreEqual(1300000, res.Out);
 }

 public void Down3()
 {
     Tnum res = new Tnum(7.5).RoundDown(0.25);
     Assert.AreEqual(7.5, res.Out);
 }