public override bool Equals(object obj)
{
UnaryExpressionFingerprint other = obj as UnaryExpressionFingerprint;
return((other != null) &&
Equals(this.Method, other.Method) &&
this.Equals(other));
}
public void Create_UnknownOperand()
{
// Arrange
ParserContext context = new ParserContext();
Expression operand = ExpressionHelper.GetUnknownExpression();
UnaryExpression expression = Expression.Convert(operand, typeof(object));
// Act
UnaryExpressionFingerprint fingerprint = UnaryExpressionFingerprint.Create(expression, context);
// Assert
Assert.IsNull(fingerprint, "Unknown operands cannot be parsed.");
}
public void Comparison_Inequality_Type() {
// Arrange
ExpressionType nodeType = ExpressionType.Not;
Type type = typeof(int);
MethodInfo method = typeof(object).GetMethod("GetHashCode");
// Act
UnaryExpressionFingerprint fingerprint1 = new UnaryExpressionFingerprint(nodeType, type, method);
UnaryExpressionFingerprint fingerprint2 = new UnaryExpressionFingerprint(nodeType, typeof(object), method);
// Assert
Assert.AreNotEqual(fingerprint1, fingerprint2, "Fingerprints should not have been equal (differ by Type).");
}
public void Create()
{
// Arrange
ParserContext context = new ParserContext();
Expression operand = Expression.Constant(TimeSpan.Zero);
UnaryExpression expression = Expression.Negate(operand);
// Act
UnaryExpressionFingerprint fingerprint = UnaryExpressionFingerprint.Create(expression, context);
// Assert
Assert.AreEqual(expression.Method, fingerprint.Method);
Assert.AreEqual(expression.Operand.NodeType, fingerprint.Operand.NodeType);
}
public void Comparison_Inequality_FingerprintType()
{
// Arrange
ExpressionType nodeType = ExpressionType.Not;
Type type = typeof(int);
MethodInfo method = typeof(object).GetMethod("GetHashCode");
// Act
UnaryExpressionFingerprint fingerprint1 = new UnaryExpressionFingerprint(nodeType, type, method);
DummyExpressionFingerprint fingerprint2 = new DummyExpressionFingerprint(nodeType, type);
// Assert
Assert.AreNotEqual(fingerprint1, fingerprint2, "Fingerprints should not have been equal ('other' is wrong type).");
}
public void Comparison_Inequality_Type()
{
// Arrange
ExpressionType nodeType = ExpressionType.Not;
Type type = typeof(int);
MethodInfo method = typeof(object).GetMethod("GetHashCode");
// Act
UnaryExpressionFingerprint fingerprint1 = new UnaryExpressionFingerprint(nodeType, type, method);
UnaryExpressionFingerprint fingerprint2 = new UnaryExpressionFingerprint(nodeType, typeof(object), method);
// Assert
Assert.NotEqual(fingerprint1, fingerprint2);
}
public void Comparison_Equality() {
// Arrange
ExpressionType nodeType = ExpressionType.Not;
Type type = typeof(int);
MethodInfo method = typeof(object).GetMethod("GetHashCode");
// Act
UnaryExpressionFingerprint fingerprint1 = new UnaryExpressionFingerprint(nodeType, type, method);
UnaryExpressionFingerprint fingerprint2 = new UnaryExpressionFingerprint(nodeType, type, method);
// Assert
Assert.AreEqual(fingerprint1, fingerprint2, "Fingerprints should have been equal.");
Assert.AreEqual(fingerprint1.GetHashCode(), fingerprint2.GetHashCode(), "Fingerprints should have been different.");
}
public void Comparison_Inequality_Method()
{
// Arrange
ExpressionType nodeType = ExpressionType.Not;
Type type = typeof(int);
MethodInfo method = typeof(object).GetMethod("GetHashCode");
// Act
UnaryExpressionFingerprint fingerprint1 = new UnaryExpressionFingerprint(nodeType, type, method);
UnaryExpressionFingerprint fingerprint2 = new UnaryExpressionFingerprint(nodeType, type, null /* method */);
// Assert
Assert.NotEqual(fingerprint1, fingerprint2);
}
public void Properties() {
// Arrange
ExpressionType expectedNodeType = ExpressionType.Not;
Type expectedType = typeof(int);
MethodInfo expectedMethod = typeof(object).GetMethod("GetHashCode");
// Act
UnaryExpressionFingerprint fingerprint = new UnaryExpressionFingerprint(expectedNodeType, expectedType, expectedMethod);
// Assert
Assert.AreEqual(expectedNodeType, fingerprint.NodeType);
Assert.AreEqual(expectedType, fingerprint.Type);
Assert.AreEqual(expectedMethod, fingerprint.Method);
}
public void Comparison_Inequality_Method()
{
// Arrange
ExpressionType nodeType = ExpressionType.Not;
Type type = typeof(int);
MethodInfo method = typeof(object).GetMethod("GetHashCode");
// Act
UnaryExpressionFingerprint fingerprint1 = new UnaryExpressionFingerprint(nodeType, type, method);
UnaryExpressionFingerprint fingerprint2 = new UnaryExpressionFingerprint(nodeType, type, null /* method */);
// Assert
Assert.AreNotEqual(fingerprint1, fingerprint2, "Fingerprints should not have been equal (differ by Method).");
}
public void ToExpression()
{
// Arrange
ParserContext context = new ParserContext();
UnaryExpression expression = Expression.Negate(Expression.Constant(TimeSpan.Zero));
UnaryExpressionFingerprint fingerprint = UnaryExpressionFingerprint.Create(expression, context);
// Act
UnaryExpression result = (UnaryExpression)fingerprint.ToExpression(context);
// Assert
Assert.AreEqual(ExpressionType.Negate, result.NodeType);
Assert.AreEqual(ExpressionType.Convert, result.Operand.NodeType); // constants are converted to casts
}
public void Properties()
{
// Arrange
ExpressionType expectedNodeType = ExpressionType.Not;
Type expectedType = typeof(int);
MethodInfo expectedMethod = typeof(object).GetMethod("GetHashCode");
// Act
UnaryExpressionFingerprint fingerprint = new UnaryExpressionFingerprint(expectedNodeType, expectedType, expectedMethod);
// Assert
Assert.Equal(expectedNodeType, fingerprint.NodeType);
Assert.Equal(expectedType, fingerprint.Type);
Assert.Equal(expectedMethod, fingerprint.Method);
}
public void Comparison_Equality()
{
// Arrange
ExpressionType nodeType = ExpressionType.Not;
Type type = typeof(int);
MethodInfo method = typeof(object).GetMethod("GetHashCode");
// Act
UnaryExpressionFingerprint fingerprint1 = new UnaryExpressionFingerprint(nodeType, type, method);
UnaryExpressionFingerprint fingerprint2 = new UnaryExpressionFingerprint(nodeType, type, method);
// Assert
Assert.AreEqual(fingerprint1, fingerprint2, "Fingerprints should have been equal.");
Assert.AreEqual(fingerprint1.GetHashCode(), fingerprint2.GetHashCode(), "Fingerprints should have been different.");
}
public void ToExpression_UnaryPlus()
{
// in .NET 3.5 SP1, Expression.MakeUnary() throws if NodeType is UnaryPlus,
// so this is special-cased by UnaryExpressionFingerprint
// Arrange
ParserContext context = new ParserContext();
UnaryExpression expression = Expression.UnaryPlus(Expression.Constant(TimeSpan.Zero));
UnaryExpressionFingerprint fingerprint = UnaryExpressionFingerprint.Create(expression, context);
// Act
UnaryExpression result = (UnaryExpression)fingerprint.ToExpression(context);
// Assert
Assert.AreEqual(ExpressionType.UnaryPlus, result.NodeType);
Assert.AreEqual(ExpressionType.Convert, result.Operand.NodeType); // constants are converted to casts
}
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_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_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.");
}
