Beispiel #1
0
        public void TraceBarSimpleValues()
        {
            var bar = new TraceBar();

            bar.UpperLimit = 5;
            bar.LowerLimit = -2.4;

            var bar1 = bar.GetBar(2.5);

            Assert.AreEqual(Verdict.Pass, bar.CombinedVerdict);
            Assert.IsTrue(bar1.Contains('|'));
            bar.GetBar(4);
            Assert.AreEqual(Verdict.Pass, bar.CombinedVerdict);
            bar.GetBar(-2.6);
            Assert.AreEqual(Verdict.Fail, bar.CombinedVerdict);
            bar.GetBar(-20);
            Assert.AreEqual(Verdict.Fail, bar.CombinedVerdict);
            var bar2 = bar.GetBar(-200000);

            Assert.IsTrue(bar2.Contains('<') && bar2.Contains("Fail"));
            Assert.AreEqual(Verdict.Fail, bar.CombinedVerdict);
            var bar3 = bar.GetBar(200000);

            Assert.IsTrue(bar3.Contains('>') && bar3.Contains("Fail"));
            Assert.AreEqual(Verdict.Fail, bar.CombinedVerdict);
        }
Beispiel #2
0
 public void TraceBarOutsiderValues()
 {
     double[] outliers = new Double[] { Double.PositiveInfinity, Double.NegativeInfinity, Double.NaN };
     foreach (var outlier in outliers)
     {
         var bar = new TraceBar();
         bar.UpperLimit = 5;
         bar.LowerLimit = -2.3;
         bar.GetBar(2.5);
         Assert.AreEqual(Verdict.Pass, bar.CombinedVerdict);
         bar.GetBar(-1);
         Assert.AreEqual(Verdict.Pass, bar.CombinedVerdict);
         var barString = bar.GetBar(outlier);
         if (double.IsNaN(outlier))
         {
             Assert.AreEqual(Verdict.Inconclusive, bar.CombinedVerdict);
             StringAssert.Contains("Inconclusive", barString);
         }
         else
         {
             Assert.AreEqual(Verdict.Fail, bar.CombinedVerdict);
             StringAssert.Contains("Fail", barString);
         }
     }
 }
Beispiel #3
0
        public override void Run()
        {
            // There are four levels of log messages Info, Warning, Error, Debug.
            MyLog.Info("Info from Run");
            for (int i = 0; i < 10; i++)
            {
                MyLog.Debug("Debug {0} from Run", i); // MyLog.X works like string.Format with regards to arguments.
            }
            MyLog.Warning("Warning from Run");
            MyLog.Error("Error from Run");

            // The Log can accept a Stopwatch Object to be used for timing analysis.
            Stopwatch sw1 = Stopwatch.StartNew();

            TapThread.Sleep(100);
            MyLog.Info(sw1, "Info from Run");

            Stopwatch sw2 = Stopwatch.StartNew();

            TapThread.Sleep(200);
            MyLog.Error(sw2, "Error from step");

            // Tracebar can be used to show results in the MyLog.
            var traceBar = new TraceBar();

            traceBar.LowerLimit = -3.0;
            for (var i = -2; i < 11; i++)
            {
                traceBar.UpperLimit = i < 5 ? 3 : 15;
                // GetBar returns a string with value, low limit, a dashed line
                // indicating magnitude, the upper limit, and (if failing), a fail indicator.
                string temp = traceBar.GetBar(i);
                MyLog.Info("MyResult: " + temp);
                TapThread.Sleep(200);
            }
            // Sample output shown below.
            //   MyResult: 2.00 - 3-------------------------|-----  3
            //   MyResult: 3.00 - 3------------------------------ | 3
            //   MyResult: 4.00 - 3------------------------------ > 3  Fail
            //   MyResult: 5.00 - 3------------ -| -----------------15
            //   MyResult: 6.00 - 3-------------- -| ---------------15

            // TraceBar remembers if any results failed, so it can be used for the verdict.
            UpgradeVerdict(traceBar.CombinedVerdict);

            // The log also supports showing stack traces.
            // Useful for debugging.
            try
            {
                throw new Exception("My exception");
            }
            catch (Exception e)
            {
                MyLog.Error("Caught exception: '{0}'", e.Message);
                MyLog.Debug(e); // Prints the stack trace to the MyLog.
            }
        }