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));
}
