/// <summary> /// Initializes new instance of the <see cref="ValueComparisonAttribute"/> class. /// </summary> /// <param name="otherProperty">The name of the other property.</param> /// <param name="comparison">The <see cref="ValueComparison"/> to perform between values.</param> public ValueComparisonAttribute(string propertyName, ValueComparison comparison) : base(propertyName) { this.comparison = comparison; this.failure = new ValidationResult(String.Empty); this.success = ValidationResult.Success; }
public bool Compare(ComparisonContext context, ValueComparison valueComparison) { bool areEqual; var options = context.Rules.GetOptions<FloatValueComparatorOptions>(valueComparison); if (valueComparison.PropertyInfo.PropertyType == typeof(float)) { areEqual = this.CompareFloats( (float)valueComparison.ExpectedValue, (float)valueComparison.ActualValue, options.FloatEpsilon); } else { areEqual = this.CompareDoubles( (double)valueComparison.ExpectedValue, (double)valueComparison.ActualValue, options.DoubleEpsilon); } if (!areEqual) { context.AddDifference(valueComparison); } return areEqual; }
public static bool Check <T>(this ValueComparison comp, T lhs, T rhs) where T : IComparable <T> { switch (comp) { case ValueComparison.Less: return(lhs.CompareTo(rhs) < 0); case ValueComparison.LessOrEqual: return(lhs.CompareTo(rhs) <= 0); case ValueComparison.Greater: return(lhs.CompareTo(rhs) > 0); case ValueComparison.GreaterOrEqual: return(lhs.CompareTo(rhs) >= 0); case ValueComparison.Equal: return(lhs.CompareTo(rhs) == 0); case ValueComparison.NotEqual: return(lhs.CompareTo(rhs) != 0); } return(false); }
public bool Compare(ComparisonContext context, ValueComparison comparison) { if (comparison.PropertyType == null) { throw new ArgumentException("Could not determine type to reflect.", "comparison"); } var areEqual = true; var properties = comparison.PropertyType .GetProperties(BindingFlags.Instance | BindingFlags.Public); foreach (var property in properties) { var propertyPathItem = new PropertyPathItem(property, comparison.PropertyPathItem); var expectedPropValue = property.GetValue(comparison.ExpectedValue, null); var actualPropValue = property.GetValue(comparison.ActualValue, null); if (!context.CompareItem(expectedPropValue, actualPropValue, propertyPathItem)) { areEqual = false; } } return areEqual; }
public void ValueComparisonTest1(string testCase, string toleranceString, string compareTypeString, string expected, string actual, string issueString, string resultExpected, string resultActual, string resultDelta) { var testName = "Test " + testCase; var tolerance = Tolerance.Parse(toleranceString); ("Precision parsed:" + tolerance.Precision).Log(); var issue = (CompareOutcome)Enum.Parse(typeof(CompareOutcome), issueString); var compareType = string.IsNullOrEmpty(compareTypeString) ? null : Type.GetType(compareTypeString); var comparison = new ValueComparison(expected, actual, tolerance, compareType); Assert.AreEqual(issue, comparison.Outcome, testName + "-Issue"); if (!string.IsNullOrEmpty(resultExpected)) { Assert.AreEqual(resultExpected, comparison.ExpectedValueOut ?? string.Empty, testName + "-Expected"); } if (!string.IsNullOrEmpty(resultActual)) { Assert.AreEqual(resultActual, comparison.ActualValueOut ?? string.Empty, testName + "-Actual"); } if (!string.IsNullOrEmpty(resultDelta)) { Assert.AreEqual(resultDelta, comparison.DeltaOut ?? string.Empty, testName + "-Delta"); } }
private bool CompareArrayItems(ComparisonContext context, ValueComparison comparison, int currentDimension, int[] currentIndices) { var actual = (Array)comparison.ActualValue; var expected = (Array)comparison.ExpectedValue; var length = expected.GetLength(currentDimension); var areEqual = true; for (var i = 0; i < length; i++) { currentIndices[currentDimension] = i; if (currentDimension == currentIndices.Length - 1) { // Last dimension, get value and compare var actualValue = actual.GetValue(currentIndices); var expectedValue = expected.GetValue(currentIndices); var indicesString = this.GetArrayIndicesString(currentIndices); var propertyPath = new PropertyPathItem(indicesString, comparison.PropertyPathItem); if (!context.CompareItem(expectedValue, actualValue, propertyPath)) { areEqual = false; } } else { if (!this.CompareArrayItems(context, comparison, currentDimension + 1, currentIndices)) { areEqual = false; } } } return areEqual; }
public bool Compare(ComparisonContext comparisonContext, ValueComparison valueComparison) { var actual = (IDictionary)valueComparison.ActualValue; var expected = (IDictionary)valueComparison.ExpectedValue; if (!this.AreKeysEqual(expected, actual, comparisonContext, valueComparison)) { return false; } foreach (var key in expected.Keys) { var actualValue = actual[key]; var expectedValue = expected[key]; // TODO: Why is this immediately picked up by the recursive comparator // TODO: Create a valid use case test for the recursive comparator // TODO: Both values null in the dictionary // TODO: Comple objects in the dictionary var propertyPath = new PropertyPathItem(key.ToString(), valueComparison.PropertyPathItem); comparisonContext.CompareItem(expectedValue, actualValue, propertyPath); } return true; }
public void constructFunction(ComparedValue comparedValue, ValueComparison comparison, float value) { var comparisonFunction = getComparison(comparison, value); var valueFunction = getValueFunction(comparedValue); func = (c1, c2, f) => comparisonFunction(valueFunction(c1, c2, f)); }
internal ColorDistanceDifference(int x, int y, float expected, float found, ValueComparison comparison) { PixelPosition = new Point(x, y); this.expected = expected; this.found = found; this.comparison = comparison; }
public void ConstructorThrowsExceptionIfPropertyNameIsEmptyString() { // Act var c = new ValueComparison(String.Empty, Enums.ComparisonOperators.EQ, new List <string>(1) { "A Value" }); }
public void ConstructorThrowsExceptionIfPropertyNameIsWhiteSpace() { // Act var c = new ValueComparison(" ", Enums.ComparisonOperators.EQ, new List <string>(1) { "A Value" }); }
public DateCompareAttribute(ValueComparison comparison) { if (!Enum.IsDefined(typeof(ValueComparison), comparison)) throw new ArgumentException("Undefined value.", "comparison"); this.comparison = comparison; this.compareProperty = ""; }
public void ThenShouldReturnTrueIfValuesAreRefEqual() { var actual = "AAA"; var expected = "BBB"; var comparisonA = new ValueComparison(propPath, expected, actual); var comparisonB = new ValueComparison(propPath, expected, actual); comparisonB.Equals(comparisonA).Should().BeTrue(); }
public CellComparison( int row, string rowName, int column, string columName, object expected, object actual, Tolerance tolerance = null) { Row = row; RowName = rowName; Column = column; ColumnName = columName; Cell = new ValueComparison(expected, actual, tolerance); }
public void ThenShouldReturnFalseIfValuesAreNotRefEqual() { var actual = "AAA"; var expected = "BBB"; var comparisonA = new ValueComparison(propPath, expected.EnsureUniqueInstance(), actual); var comparisonB = new ValueComparison(propPath, expected.EnsureUniqueInstance(), actual); comparisonB.Equals(comparisonA).Should().BeFalse(); }
/// <summary> /// Initializes new instance of the <see cref="DateTimeCompareAttribute"/> class. /// </summary> /// <param name="otherProperty">The name of the other property.</param> /// <param name="comparison">The <see cref="ValueComparison"/> to perform between values.</param> public DateTimeCompareAttribute(string otherProperty, ValueComparison comparison) : base(otherProperty) { if (!Enum.IsDefined(typeof(ValueComparison), comparison)) throw new ArgumentException("Undefined value.", "comparison"); this.comparison = comparison; this.success = ValidationResult.Success; this.failure = new ValidationResult(String.Empty); }
public bool Compare(ComparisonContext context, ValueComparison comparison) { var areEqual = object.Equals(comparison.ExpectedValue, comparison.ActualValue); if (!areEqual) { context.AddDifference(comparison); } return areEqual; }
private void TestWithNull(string value, Enums.ComparisonOperators comparison) { var c = new ValueComparison("A Property", comparison, new List <string>(1) { "A Value" }); var result = c.Compare(value); Assert.IsTrue(result); }
public DateTimeCompareAttribute(string otherProperty, ValueComparison comparison) : base(otherProperty) { if (!Enum.IsDefined(typeof(ValueComparison), comparison)) { throw new ArgumentException("Undefined value", "comparison"); } this.comparison = comparison; this.success = ValidationResult.Success; this.failure = new ValidationResult(String.Empty); }
public bool Compare(ComparisonContext context, ValueComparison comparison) { var areEqual = ReferenceEquals(comparison.ExpectedValue, comparison.ActualValue); if (!areEqual) { comparison.Message = "The instances are different, reference equals failed."; context.AddDifference(comparison); } return areEqual; }
private ValueComparison CreateKeyNamedComparison(ValueComparison comparison, string key, string messageFormat) { var itemPropPath = new PropertyPathItem(key, comparison.PropertyPathItem); var result = new ValueComparison( itemPropPath, comparison.ExpectedValue, comparison.ActualValue); result.Message = string.Format(messageFormat, key); return result; }
public RequiredIfAttribute(string otherPropertyName, object compare, ValueComparison comparison) : base(otherPropertyName) { if (!Enum.IsDefined(typeof(ValueComparison), comparison)) { throw new ArgumentException("Undefined value.", "comparison"); } this.comparison = comparison; this.success = ValidationResult.Success; this.failure = new ValidationResult(String.Empty); this.compare = compare; }
public bool Compare(ComparisonContext comparisonContext, ValueComparison valueComparison) { var expected = (IComparable)valueComparison.ExpectedValue; var actual = (IComparable)valueComparison.ActualValue; var areEqual = expected.CompareTo(actual) == 0; if (!areEqual) { comparisonContext.AddDifference(valueComparison); } return areEqual; }
public bool Compare(ComparisonContext context, ValueComparison comparison) { var maxDimentions = comparison.PropertyType.GetArrayRank(); var currentIndices = new int[maxDimentions]; if (!this.CompareArrayDimensionLengths(comparison, maxDimentions)) { context.AddDifference(comparison); return false; } return this.CompareArrayItems(context, comparison, 0, currentIndices); }
public void ValueComparisonReturnsFalseOnNotIn() { // Arrange var c = new ValueComparison("A Property", Enums.ComparisonOperators.NOTIN, new List <string>(2) { "A Value", "B Value" }); // Act var result = c.Compare("A Value"); // Assert Assert.IsFalse(result); }
public void ThenLogEventShouldHavePropertiesSet() { var context = new ValueComparison(null, null, null); var logger = new Logger(); logger.Callback(x => { x.Message.Should().Be("Hello, world!"); x.Level.Should().Be(LogLevel.Error); x.Comparison.Should().NotBeNull(); }); logger.Log(LogLevel.Error, context, "Hello, {0}!", "world"); }
public void ValueComparisonReturnsTrueOnNotEquals() { // Arrange var c = new ValueComparison("A Property", Enums.ComparisonOperators.NOTEQ, new List <string>(1) { "A Value" }); // Act var result = c.Compare("Not A Value"); // Assert Assert.IsTrue(result); }
public bool Compare(ComparisonContext context, ValueComparison valueComparison) { var options = context.Rules.GetOptions<StringValueComparatorOptions>(valueComparison); var areEqual = string.Equals( (string)valueComparison.ExpectedValue, (string)valueComparison.ActualValue, options.ComparisonType); if (!areEqual) { context.AddDifference(valueComparison); } return areEqual; }
public bool Compare(ComparisonContext context, ValueComparison comparison) { var areSame = this.customCompare.Invoke(comparison, context); if (!areSame) { if (string.IsNullOrEmpty(comparison.Message)) { comparison.Message = "Custom comparator returned false"; } context.AddDifference(comparison); } return areSame; }
public bool Compare(ComparisonContext context, ValueComparison comparison) { var areEqual = true; var options = context.Rules.GetOptions<CollectionValueComparatorOptions>(comparison); var actual = (IEnumerable)comparison.ActualValue; var expected = (IEnumerable)comparison.ExpectedValue; if (options.OrderFunction != null) { actual = options.OrderFunction.Invoke(actual); expected = options.OrderFunction.Invoke(expected); } var actualEnumerator = actual.GetEnumerator(); var expectedEnumerator = expected.GetEnumerator(); var actualHasNext = actualEnumerator.MoveNext(); var expectedHasNext = expectedEnumerator.MoveNext(); var itemCounter = 0; while (actualHasNext && expectedHasNext) { var propertyPath = new PropertyPathItem(itemCounter.ToString(), comparison.PropertyPathItem); if (!context.CompareItem(expectedEnumerator.Current, actualEnumerator.Current, propertyPath)) { areEqual = false; } expectedHasNext = expectedEnumerator.MoveNext(); actualHasNext = actualEnumerator.MoveNext(); itemCounter++; } if (actualHasNext != expectedHasNext) { comparison.Message = string.Format( "The collections have a different number of items, expected: {0}, actual: {1}.", expected.Cast<object>().Count(), actual.Cast<object>().Count()); context.AddDifference(comparison); areEqual = false; } return areEqual; }
public bool IsMatch(ValueComparison valueComparison) { if (valueComparison.PropertyPathItem.IsRoot) { return this.AppliesToRoot; } if (this.PropertyType != null) { var propType = valueComparison.PropertyType; if (this.IncludeInheritedTypes && !propType.IsSubclassOf(this.PropertyType) && propType != this.PropertyType) { return false; } if (!this.IncludeInheritedTypes && propType != this.PropertyType) { return false; } } if (this.DeclarationType != null && valueComparison.PropertyInfo != null) { if (valueComparison.PropertyInfo.DeclaringType != this.DeclarationType) { return false; } } if (this.Predicate != null && !this.Predicate.Invoke(valueComparison)) { return false; } if (this.PropertyExpression != null) { var propertyNames = this.PropertyExpression.GetPropertyNames(); if (!this.IsPropertyPathMatch(valueComparison.PropertyPathItem, propertyNames)) { return false; } } return true; }
private bool CompareArrayDimensionLengths(ValueComparison comparison, int maxDimensions) { var actual = (Array)comparison.ActualValue; var expected = (Array)comparison.ExpectedValue; for (var i = 0; i < maxDimensions; i++) { var actualLength = actual.GetLength(i); var expectedLength = expected.GetLength(i); if (actualLength != expectedLength) { comparison.Message = string.Format("The arrays have different lengths at the dimension {0}", i); return false; } } return true; }
private static Func <float, bool> getComparison( ValueComparison comparison, float value) { switch (comparison) { case ValueComparison.GreaterThan: return(x => x > value); case ValueComparison.LessThan: return(x => x < value); case ValueComparison.NotEqualTo: return(x => x != value); default: case ValueComparison.EqualTo: return(x => x == value); } }
private bool AreKeysEqual(IDictionary expected, IDictionary actual, ComparisonContext comparisonContext, ValueComparison valueComparison) { var notInExpected = actual.Keys .Cast<object>() .Where(x => !expected.Contains(x)); var notInActual = expected.Keys .Cast<object>() .Where(x => !actual.Contains(x)); var result = true; foreach (var key in notInActual) { var keyComparison = this.CreateKeyNamedComparison( valueComparison, key.ToString(), "The dictionaries differ, the key '{0}' is missing in the actual value."); comparisonContext.AddDifference(keyComparison); result = false; } foreach (var key in notInExpected) { var keyComparison = this.CreateKeyNamedComparison( valueComparison, key.ToString(), "The dictionaries differ, there is an extra key '{0}' in the actual value."); comparisonContext.AddDifference(keyComparison); result = false; } return result; }
private static Func<float, bool> getComparison( ValueComparison comparison, float value) { switch(comparison) { case ValueComparison.GreaterThan: return x => x > value; case ValueComparison.LessThan: return x => x < value; case ValueComparison.NotEqualTo: return x => x != value; default: case ValueComparison.EqualTo: return x => x == value; } }
public override bool IsMatch(ValueComparison valueComparison) { return this.Selection.IsMatch(valueComparison); }
public abstract bool IsMatch(ValueComparison valueComparison);
static public string Parse(ValueComparison value) { switch (value) { case ValueComparison.LessThan: return "Less than"; case ValueComparison.Equals: return "Equals"; case ValueComparison.GreaterThan: return "Greater Than"; default: throw new ArgumentException("Parse() has no support for " + ParseType(value)); } }
private string getValueComparisonString(ValueComparison comparison) { string value = ""; switch (comparison) { case ValueComparison.IsEqual: value = "="; break; case ValueComparison.IsNotEqual: value = "!="; break; case ValueComparison.IsGreaterThan: value = ">"; break; case ValueComparison.IsGreaterThanOrEqual: value = ">="; break; case ValueComparison.IsLessThan: value = "<"; break; case ValueComparison.IsLessThanOrEqual: value = "<="; break; } return value; }
public void ConstructorThrowsExceptionIfValidValuesIsNull() { // Act var c = new ValueComparison("A property", Enums.ComparisonOperators.EQ, null); }
//--------------------------------------------------------------------------- // TestStep for TextPatternRange.CompareEndpoints Method //--------------------------------------------------------------------------- internal void TS_CompareEndpoints(TextPatternRange callingRange, TextPatternRangeEndpoint endPoint, TextPatternRange argumentRange, TextPatternRangeEndpoint targetEndPoint, ValueComparison valueComparison, Type expectedException, CheckType checkType) { int endPointOffset = 0; string msg = endPoint.ToString() + "/" + targetEndPoint.ToString(); Range_CompareEndpoints(callingRange, endPoint, argumentRange, targetEndPoint, ref endPointOffset, expectedException, checkType); IsMatchingValue(endPointOffset, valueComparison, 0, msg, checkType); m_TestStep++; }
public bool IsOk() => ValueComparison.IsOk(Outcome);
public ValueCondition(ComparedValue comparedValue, ValueComparison comparison, float value) { constructFunction(comparedValue, comparison, value); }
static internal void IsMatchingValue(int actual, ValueComparison valueComparison, int expected, string msg, CheckType checkType) { bool result = false; Comment("Expecting " + actual + " " + valueComparison.ToString() + " " + expected); switch (valueComparison) { case ValueComparison.LessThan: result = (actual < expected); break; case ValueComparison.Equals: result = (actual == expected); break; case ValueComparison.GreaterThan: result = (actual > expected); break; default: throw new ArgumentException("IsMatchingValue() has no support for " + ParseType(valueComparison)); } if (result == true) Comment(msg + " results matched as expected, ValueComparison = " + Parse(valueComparison)); else { Comment("Evaluated " + actual + " " + valueComparison + " " + expected + " as " + result); ThrowMe(checkType, msg + " results were not as expected "); } }
/// --------------------------------------------------------------------------- /// <summary>Parses values for enum</summary> /// --------------------------------------------------------------------------- static public string ParseType(ValueComparison value) { return ParseType(value.GetType().ToString(), value.ToString()); }
//--------------------------------------------------------------------------- // Helper for CompareEndpoints() test cases //--------------------------------------------------------------------------- internal void CompareEndpointsHelper(SampleText sampleText, TargetRangeType callingRangeType, TargetRangeType argumentRangeType, ValueComparison startStart, ValueComparison startEnd, ValueComparison endStart, ValueComparison endEnd, Type expectedException) { TextPatternRange callingRange = null; TextPatternRange argumentRange = null; // Pre-Condition Verify text is expected value <<sampleText>> TS_SetText(sampleText, CheckType.IncorrectElementConfiguration); // Pre-Condition Create calling range = <<callingRangeType>> TS_CreateRange(out callingRange, callingRangeType, null, true, CheckType.Verification); // Pre-Condition Create argument range = <<argumentRangeType>> TS_CreateRange(out argumentRange, argumentRangeType, callingRange, true, CheckType.Verification); // Verify CompareEndPoints(start,start) <<startStart>> zero TS_CompareEndpoints(callingRange, TextPatternRangeEndpoint.Start, argumentRange, TextPatternRangeEndpoint.Start, startStart, expectedException, CheckType.Verification); // Verify CompareEndPoints(start, end) <<startEnd>> zero TS_CompareEndpoints(callingRange, TextPatternRangeEndpoint.Start, argumentRange, TextPatternRangeEndpoint.End, startEnd, expectedException, CheckType.Verification); // Verify CompareEndPoints( end,start) <<endStart>> zero TS_CompareEndpoints(callingRange, TextPatternRangeEndpoint.End, argumentRange, TextPatternRangeEndpoint.Start, endStart, expectedException, CheckType.Verification); // Verify CompareEndPoints( end, end) <<endEnd>> zero TS_CompareEndpoints(callingRange, TextPatternRangeEndpoint.End, argumentRange, TextPatternRangeEndpoint.End, endEnd, expectedException, CheckType.Verification); }
public void ConstructorThrowsExceptionIfValidValuesIsEmptyList() { // Act var c = new ValueComparison("A property", Enums.ComparisonOperators.EQ, new List <string>()); }