private string toString(Antecedent antecedent, Codification codebook, CultureInfo culture) { int index = antecedent.Index; String name = Variables[index].Name; if (String.IsNullOrEmpty(name)) { name = "x[" + index + "]"; } String op = ComparisonExtensions.ToString(antecedent.Comparison); String value; if (codebook != null && codebook.Columns.Contains(name)) { value = codebook.Translate(name, (int)antecedent.Value); } else { value = antecedent.Value.ToString(culture); } return(String.Format(culture, "{0} {1} {2}", name, op, value)); }
private static void CheckSerializationForType(Fixture fixture, Type messageType, object message = null) { Console.Write("Testing {0} ", messageType.Name); if (message == null) { var genericMethod = _createMethod.MakeGenericMethod(messageType); message = genericMethod.Invoke(null, new object[] { fixture }); } Console.WriteLine("{{{0}}}", message); var bytes = _serializer.Serialize(message); var messageCopy = _serializer.Deserialize(messageType, bytes); NUnitExtensions.ShouldNotBeNull(messageCopy); var comparer = ComparisonExtensions.CreateComparer(); comparer.Config.MembersToIgnore = new List <string> { "Item" }; var result = comparer.Compare(message, messageCopy); if (!result.AreEqual) { Assert.Fail(result.DifferencesString); } }
public void should_ignore_static_members_in_comparison() { var comparer = ComparisonExtensions.CreateComparer(); var foo1 = new Foo(); var foo2 = new Foo(); var result = comparer.Compare(foo1, foo2); result.AreEqual.ShouldBeTrue(); }
public static void ShouldHaveSamePropertiesAs(this object actual, object expected, params string[] ignoredProperties) { var comparer = ComparisonExtensions.CreateComparer(); comparer.ElementsToIgnore.AddRange(ignoredProperties); if (!comparer.Compare(actual, expected)) { Assert.Fail("Properties should be equal, invalid properties: " + comparer.DifferencesString); } }
public static object ShouldEqualDeeply(this object actual, object expected) { var comparer = ComparisonExtensions.CreateComparer(); var areEqual = comparer.Compare(actual, expected); if (!areEqual) { Console.WriteLine(comparer.DifferencesString); } Assert.IsTrue(areEqual); return(expected); }
public void ExpectNot(params TransportMessageSent[] notExpectedMessages) { var comparer = ComparisonExtensions.CreateComparer(); foreach (var notExpectedMessage in notExpectedMessages) { var matchingMessage = Messages.FirstOrDefault(x => comparer.Compare(notExpectedMessage, x).AreEqual); if (matchingMessage != null) { Assert.Fail("Found message matching " + notExpectedMessage.TransportMessage.MessageTypeId.GetMessageType().Name); } } }
public static void ShouldHaveSamePropertiesAs(this object actual, object expected, params string[] ignoredProperties) { var comparer = ComparisonExtensions.CreateComparer(); comparer.Config.MembersToIgnore.AddRange(ignoredProperties); var result = comparer.Compare(actual, expected); if (!result.AreEqual) { Assert.Fail("Properties should be equal, invalid properties: " + result.DifferencesString); } }
public bool Evaluate(CompareOperator inComparison, RSValue inCheck, RSValue inValue) { switch (inCheck.GetInnerType()) { case RSValue.InnerType.Null: return(ComparisonExtensions.Evaluate(inComparison, false, inCheck.GetInnerType() != RSValue.InnerType.Null)); case RSValue.InnerType.Int32: return(ComparisonExtensions.Evaluate(inComparison, inCheck.AsInt, inValue.AsInt)); case RSValue.InnerType.Bool: return(ComparisonExtensions.Evaluate(inComparison, inCheck.AsBool, inValue.AsBool)); case RSValue.InnerType.Color: return(ComparisonExtensions.EvaluateEquatable(inComparison, inCheck.AsColor, inValue.AsColor)); case RSValue.InnerType.Float: return(ComparisonExtensions.Evaluate(inComparison, inCheck.AsFloat, inValue.AsFloat)); case RSValue.InnerType.Vector2: return(ComparisonExtensions.EvaluateEquatable(inComparison, inCheck.AsVector2, inValue.AsVector2)); case RSValue.InnerType.Vector3: return(ComparisonExtensions.EvaluateEquatable(inComparison, inCheck.AsVector3, inValue.AsVector3)); case RSValue.InnerType.Vector4: return(ComparisonExtensions.EvaluateEquatable(inComparison, inCheck.AsVector4, inValue.AsVector4)); case RSValue.InnerType.String: return(ComparisonExtensions.Evaluate(inComparison, inCheck.AsString, inValue.AsString)); case RSValue.InnerType.Enum: return(ComparisonExtensions.Evaluate(inComparison, inCheck.AsInt, inValue.AsInt)); case RSValue.InnerType.EntityScope: return(ComparisonExtensions.EvaluateReferenceEquals(inComparison, ResolveEntity(inCheck.AsEntity).ForceSingle(), ResolveEntity(inValue.AsEntity).ForceSingle())); default: throw new ArgumentException("Invalid value type " + inCheck.GetInnerType(), "inCheck"); } }
TreeNode BuildTreeNode(DecisionNode node, string attribute_name) { if (node.Decision != null) { return(new TreeNode(ComparisonExtensions.ToString(node.Comparison) + " " + codifier[attribute_name][Convert.ToDouble(node.Value)] + " THEN " + codifier.First().Value[Convert.ToDouble(node.Decision)])); } List <TreeNode> child_nodes = new List <TreeNode>(); for (int i = 0; i < node.Branches.Count(); ++i) { child_nodes.Add(BuildTreeNode(node.Branches[i], node.Attribute.Name)); } if (node.Value != null) { return(new TreeNode(ComparisonExtensions.ToString(node.Comparison) + " " + codifier[attribute_name][Convert.ToDouble(node.Value)] + " THEN IF " + node.Attribute.Name, child_nodes.ToArray())); } else { return(new TreeNode("IF " + node.Attribute.Name, child_nodes.ToArray())); } }
/// <summary> /// Returns a <see cref="System.String"/> that represents this instance. /// </summary> /// /// <returns> /// A <see cref="System.String"/> that represents this instance. /// </returns> /// public override string ToString() { string op = ComparisonExtensions.ToString(Comparison); return(String.Format("x[{0}] {1} {2}", Index, op, Value)); }