private void CompareExpectedToActuals(IReadOnlyDictionary <DateTime, Measurement> actualDictionary)
 {
     foreach (var expectedEntry in _expected.Measurements)
     {
         actualDictionary.TryGetValue(expectedEntry.Timestamp, out var actual);
         var comparison = new MeasurementComparison(expectedEntry, actual, _tolerance, _compareType);
         if (actual != null)
         {
             actual.IsChecked = true;
         }
         _result.AddWithCheck(expectedEntry.Timestamp, comparison, "expected");
     }
 }
Example #2
0
        public void MeasurementComparisonTest1(string testCase, string toleranceString, string compareTypeString,
                                               string expectedTimeStamp, string expectedValue, bool?expectedIsGood, string actualTimeStamp, string actualValue, bool?actualIsGood,
                                               string issue,
                                               string resultTimestamp, string resultDelta, string resultExpectedValue, string resultExpectedIsGood, string resultActualValue,
                                               string resultActualIsGood)
        {
            var testName = "Test " + testCase;

            var expected = string.IsNullOrEmpty(expectedTimeStamp)
                ? null
                : new Measurement
            {
                Timestamp = DateTime.Parse(expectedTimeStamp, CultureInfo.InvariantCulture),
                Value     = expectedValue,
                IsGood    = expectedIsGood ?? false,
                IsChecked = false
            };
            var actual = string.IsNullOrEmpty(actualTimeStamp)
                ? null
                : new Measurement
            {
                Timestamp = DateTime.Parse(actualTimeStamp, CultureInfo.InvariantCulture),
                Value     = actualValue,
                IsGood    = actualIsGood ?? false,
                IsChecked = false
            };


            var tolerance   = Tolerance.Parse(toleranceString);
            var compareType = string.IsNullOrEmpty(compareTypeString) ? expected?.Value.InferType() : Type.GetType(compareTypeString);

            if (compareType == null)
            {
                $"compareType == null for {testName}".Log();
            }
            ("Precision parsed:" + tolerance.Precision).Log();

            var actualResult = new MeasurementComparison(expected, actual, tolerance, compareType);

            Assert.AreEqual(issue, actualResult.OutcomeMessage, testName + "-Issue");

            AssertStringEqual(resultExpectedValue, actualResult.Value.ExpectedValueOut, testName + "-ExpectedValue");
            AssertStringEqual(resultActualValue, actualResult.Value.ActualValueOut, testName + "-ActualValue");
            AssertStringEqual(resultDelta, actualResult.Value.DeltaOut, testName + "-Delta");
            AssertBoolEqual(resultExpectedIsGood, actualResult.IsGood.ExpectedValueOut, testName + "-ExpectedIsGood");
            AssertBoolEqual(resultActualIsGood, actualResult.IsGood.ActualValueOut, testName + "-ActualIsGood");
            AssertStringEqual(resultTimestamp, actualResult.Timestamp.ValueMessage, testName + "-Timestamp");
        }