public void AddFingerprint(ExpressionFingerprint fingerprint)
{
if (fingerprint != null)
{
fingerprint.AddToHashCodeCombiner(this);
}
else
{
AddInt32(0);
}
}
public void Comparison_DifferByHoistedLocalsIndex()
{
// fingerprints are CONST[0]:int and CONST[1]:int, so not equivalent
// Arrange
ParserContext context = new ParserContext();
ExpressionFingerprint fingerprint1 = ConstantExpressionFingerprint.Create(Expression.Constant(0), context);
ExpressionFingerprint fingerprint2 = ConstantExpressionFingerprint.Create(Expression.Constant(0), context);
// Act
bool areEqual = Object.Equals(fingerprint1, fingerprint2);
// Assert
Assert.IsFalse(areEqual, "Fingerprints should not have been equivalent - differ by ConstantExpressionFingerprint.HoistedLocalsIndex.");
}
public void Comparison_DifferByIfFalse()
{
// fingerprint1 is IIF(CONST:bool, CONST:TimeSpan, CONST:TimeSpan):TimeSpan
// fingerprint2 is IIF(CONST:bool, CONST:TimeSpan, OP_NEGATE(CONST:TimeSpan):TimeSpan):TimeSpan, so not equivalent
// Arrange
ExpressionFingerprint fingerprint1 = ConditionalExpressionFingerprint.Create(Expression.Condition(Expression.Constant(true), Expression.Constant(TimeSpan.MinValue), Expression.Constant(TimeSpan.MaxValue)), new ParserContext());
ExpressionFingerprint fingerprint2 = ConditionalExpressionFingerprint.Create(Expression.Condition(Expression.Constant(true), Expression.Constant(TimeSpan.MaxValue), Expression.Negate(Expression.Constant(TimeSpan.Zero))), new ParserContext());
// Act
bool areEqual = Object.Equals(fingerprint1, fingerprint2);
// Assert
Assert.IsFalse(areEqual, "Fingerprints should not have been equivalent - differ by ConditionalExpressionFingerprint.IfTrue.");
}
public void Comparison_EquivalentExpressions()
{
// both fingerprints are ARRAY_INDEX(CONST:object[], CONST:int):object, so are equivalent
// Arrange
ExpressionFingerprint fingerprint1 = BinaryExpressionFingerprint.Create(Expression.ArrayIndex(Expression.Constant(new object[0]), Expression.Constant(0)), new ParserContext());
ExpressionFingerprint fingerprint2 = BinaryExpressionFingerprint.Create(Expression.ArrayIndex(Expression.Constant(new object[0]), Expression.Constant(0)), new ParserContext());
// Act
HashSet <ExpressionFingerprint> set = new HashSet <ExpressionFingerprint>()
{
fingerprint1,
fingerprint2
};
// Assert
Assert.AreEqual(1, set.Count, "Fingerprints should have been equivalent.");
}
public void Comparison_EquivalentExpressions()
{
// both fingerprints are CONST[0]:int, so are equivalent
// Arrange
ExpressionFingerprint fingerprint1 = ConstantExpressionFingerprint.Create(Expression.Constant(1), new ParserContext());
ExpressionFingerprint fingerprint2 = ConstantExpressionFingerprint.Create(Expression.Constant(2), new ParserContext());
// Act
HashSet <ExpressionFingerprint> set = new HashSet <ExpressionFingerprint>()
{
fingerprint1,
fingerprint2
};
// Assert
Assert.AreEqual(1, set.Count, "Fingerprints should have been equivalent.");
}
public void Comparison_EquivalentExpressions()
{
// both fingerprints are OP_NEGATE(CONST:TimeSpan):TimeSpan, so are equivalent
// Arrange
ExpressionFingerprint fingerprint1 = UnaryExpressionFingerprint.Create(Expression.Negate(Expression.Constant(TimeSpan.MinValue)), new ParserContext());
ExpressionFingerprint fingerprint2 = UnaryExpressionFingerprint.Create(Expression.Negate(Expression.Constant(TimeSpan.MaxValue)), new ParserContext());
// Act
HashSet <ExpressionFingerprint> set = new HashSet <ExpressionFingerprint>()
{
fingerprint1,
fingerprint2
};
// Assert
Assert.AreEqual(1, set.Count, "Fingerprints should have been equivalent.");
}
public void Comparison_EquivalentExpressions()
{
// both fingerprints are IIF(CONST:bool, CONST:TimeSpan, CONST:TimeSpan):TimeSpan, so are equivalent
// Arrange
ExpressionFingerprint fingerprint1 = ConditionalExpressionFingerprint.Create(Expression.Condition(Expression.Constant(true), Expression.Constant(TimeSpan.MinValue), Expression.Constant(TimeSpan.MaxValue)), new ParserContext());
ExpressionFingerprint fingerprint2 = ConditionalExpressionFingerprint.Create(Expression.Condition(Expression.Constant(true), Expression.Constant(TimeSpan.MaxValue), Expression.Constant(TimeSpan.Zero)), new ParserContext());
// Act
HashSet <ExpressionFingerprint> set = new HashSet <ExpressionFingerprint>()
{
fingerprint1,
fingerprint2
};
// Assert
Assert.AreEqual(1, set.Count, "Fingerprints should have been equivalent.");
}
public void Comparison_DifferByOperand()
{
// fingerprints are OP_NEGATE(CONST:int):int and OP_NEGATE(PARAM:int):int, so not equivalent
// Arrange
ParserContext context = new ParserContext()
{
ModelParameter = Expression.Parameter(typeof(int), "model")
};
ExpressionFingerprint fingerprint1 = UnaryExpressionFingerprint.Create(Expression.Negate(Expression.Constant(0)), context);
ExpressionFingerprint fingerprint2 = UnaryExpressionFingerprint.Create(Expression.Negate(context.ModelParameter), context);
// Act
bool areEqual = Object.Equals(fingerprint1, fingerprint2);
// Assert
Assert.IsFalse(areEqual, "Fingerprints should not have been equivalent - differ by UnaryExpressionFingerprint.Operand.");
}
public void Comparison_DifferByRight()
{
// fingerprint1 is OP_ADD(CONST:int, PARAM:int):int
// fingerprint2 is OP_ADD(CONST:int, CONST:int):int, so not equivalent
// Arrange
ParserContext context = new ParserContext()
{
ModelParameter = Expression.Parameter(typeof(int), "model")
};
ExpressionFingerprint fingerprint1 = BinaryExpressionFingerprint.Create(Expression.Add(Expression.Constant(0), context.ModelParameter), context);
ExpressionFingerprint fingerprint2 = BinaryExpressionFingerprint.Create(Expression.Add(Expression.Constant(0), Expression.Constant(0)), context);
// Act
bool areEqual = Object.Equals(fingerprint1, fingerprint2);
// Assert
Assert.IsFalse(areEqual, "Fingerprints should not have been equivalent - differ by BinaryExpressionFingerprint.Right.");
}
public void Comparison_DifferByMethod()
{
// fingerprint1 is OP_ADD(TimeSpan.op_Addition, CONST:TimeSpan, CONST:TimeSpan):TimeSpan
// fingerprint2 is OP_ADD(TimeSpan.op_Subtraction, CONST:TimeSpan, CONST:TimeSpan):TimeSpan, so not equivalent
// might be strange using op_Subtraction() for ADD, but at least it makes the Methods different
// Arrange
MethodInfo addMethod = typeof(TimeSpan).GetMethod("op_Addition", BindingFlags.Static | BindingFlags.Public);
MethodInfo subtractMethod = typeof(TimeSpan).GetMethod("op_Subtraction", BindingFlags.Static | BindingFlags.Public);
ExpressionFingerprint fingerprint1 = BinaryExpressionFingerprint.Create(Expression.Add(Expression.Constant(TimeSpan.Zero), Expression.Constant(TimeSpan.Zero), addMethod), new ParserContext());
ExpressionFingerprint fingerprint2 = BinaryExpressionFingerprint.Create(Expression.Add(Expression.Constant(TimeSpan.Zero), Expression.Constant(TimeSpan.Zero), subtractMethod), new ParserContext());
// Act
bool areEqual = Object.Equals(fingerprint1, fingerprint2);
// Assert
Assert.IsFalse(areEqual, "Fingerprints should not have been equivalent - differ by BinaryExpressionFingerprint.Method.");
}
public void Comparison_DifferByTarget()
{
// fingerprint1 is CALL(String.Clone, PARAM:string):object
// fingerprint2 is CALL(String.Clone, CONST:string):object, so not equivalent
// Arrange
ParserContext context = new ParserContext()
{
ModelParameter = Expression.Parameter(typeof(string), "model")
};
MethodInfo method = typeof(string).GetMethod("Clone");
ExpressionFingerprint fingerprint1 = MethodCallExpressionFingerprint.Create(Expression.Call(context.ModelParameter, method), context);
ExpressionFingerprint fingerprint2 = MethodCallExpressionFingerprint.Create(Expression.Call(Expression.Constant(""), method), context);
// Act
bool areEqual = Object.Equals(fingerprint1, fingerprint2);
// Assert
Assert.IsFalse(areEqual, "Fingerprints should not have been equivalent - differ by MethodCallExpressionFingerprint.Target.");
}
public void Comparison_DifferByMethod()
{
// fingerprint1 is CALL(String.ToLower, PARAM:string):string
// fingerprint1 is CALL(String.ToUpper, PARAM:string):string, so not equivalent
// Arrange
ParserContext context = new ParserContext()
{
ModelParameter = Expression.Parameter(typeof(string), "model")
};
MethodInfo toLower = typeof(string).GetMethod("ToLower", Type.EmptyTypes);
MethodInfo toUpper = typeof(string).GetMethod("ToUpper", Type.EmptyTypes);
ExpressionFingerprint fingerprint1 = MethodCallExpressionFingerprint.Create(Expression.Call(context.ModelParameter, toLower), context);
ExpressionFingerprint fingerprint2 = MethodCallExpressionFingerprint.Create(Expression.Call(context.ModelParameter, toUpper), context);
// Act
bool areEqual = Object.Equals(fingerprint1, fingerprint2);
// Assert
Assert.IsFalse(areEqual, "Fingerprints should not have been equivalent - differ by MethodCallExpressionFingerprint.Method.");
}
public void Comparison_DifferByMethod()
{
// fingerprint1 is OP_UNARYPLUS(TimeSpan.op_UnaryPlus, PARAM:TimeSpan):TimeSpan
// fingerprint2 is OP_UNARYPLUS(TimeSpan.op_UnaryNegation, PARAM:TimeSpan):TimeSpan, so not equivalent
// might be strange using op_UnaryNegation() for UNARYPLUS, but at least it makes the Methods different
// Arrange
MethodInfo unaryPlusMethod = typeof(TimeSpan).GetMethod("op_UnaryPlus", BindingFlags.Static | BindingFlags.Public);
MethodInfo negateMethod = typeof(TimeSpan).GetMethod("op_UnaryNegation", BindingFlags.Static | BindingFlags.Public);
ParserContext context = new ParserContext()
{
ModelParameter = Expression.Parameter(typeof(TimeSpan), "model")
};
ExpressionFingerprint fingerprint1 = UnaryExpressionFingerprint.Create(Expression.UnaryPlus(context.ModelParameter, unaryPlusMethod), context);
ExpressionFingerprint fingerprint2 = UnaryExpressionFingerprint.Create(Expression.UnaryPlus(context.ModelParameter, negateMethod), context);
// Act
bool areEqual = Object.Equals(fingerprint1, fingerprint2);
// Assert
Assert.IsFalse(areEqual, "Fingerprints should not have been equivalent - differ by UnaryExpressionFingerprint.Method.");
}
public void Comparison_EquivalentExpressions()
{
// both fingerprints are CALL(String.Clone, PARAM:string):object, so are equivalent
// Arrange
ParserContext context = new ParserContext()
{
ModelParameter = Expression.Parameter(typeof(string), "model")
};
MethodInfo method = typeof(string).GetMethod("Clone");
ExpressionFingerprint fingerprint1 = MethodCallExpressionFingerprint.Create(Expression.Call(context.ModelParameter, method), context);
ExpressionFingerprint fingerprint2 = MethodCallExpressionFingerprint.Create(Expression.Call(context.ModelParameter, method), context);
// Act
HashSet <ExpressionFingerprint> set = new HashSet <ExpressionFingerprint>()
{
fingerprint1,
fingerprint2
};
// Assert
Assert.AreEqual(1, set.Count, "Fingerprints should have been equivalent.");
}
protected bool Equals(ExpressionFingerprint other)
{
return((other != null) &&
(this.NodeType == other.NodeType) &&
Equals(this.Type, other.Type));
}
