public void PostIncrementAssign()
{
var expectedObject = new TestObject
{
PropertyValue = 6
};
var actualObject = new TestObject
{
PropertyValue = 6
};
var objExpr = Expression.Parameter(typeof(TestObject), "p");
var propExpr = Expression.Property(objExpr, "PropertyValue");
var expected = Expression.PostIncrementAssign(propExpr);
var expectedLambda = Expression.Lambda <Func <TestObject, int> >(expected, objExpr);
var encoded = EncodedExpression.EncodeExpression(expectedLambda);
var actualLambda = (Expression <Func <TestObject, int> >)EncodedExpression.DecodeExpression(encoded);
Assert.AreEqual(expectedLambda.ToString(), actualLambda.ToString());
Assert.AreEqual(expectedLambda.Compile().Invoke(expectedObject), actualLambda.Compile().Invoke(actualObject));
actualObject.PropertyValue = 6; // Reset for next test.
Assert.AreEqual(6, actualLambda.Compile().Invoke(actualObject));
Assert.AreEqual(7, expectedObject.PropertyValue);
}
public void EncodeDecodePrimitives([ValueSource(nameof(PrimitiveValues))] object expectedValue)
{
var expected = Expression.Constant(expectedValue, expectedValue.GetType());
var encoded = EncodedExpression.EncodeExpression(expected);
var actual = ( ConstantExpression )EncodedExpression.DecodeExpression(encoded);
Assert.AreEqual(expectedValue, actual.Value);
}
public void DecodeExpression_UnsupportedNodeType()
{
var encoded = new EncodedExpression()
{
NodeType = ExpressionType.DebugInfo
};
Assert.Throws <ArgumentException>(() => EncodedExpression.DecodeExpression(encoded));
}
public void DecodeMissingMethodIsError()
{
var parameterExpr = Expression.Parameter(typeof(MethodCallTest), "a");
var expected = Expression.Call(parameterExpr, typeof(MethodCallTest).GetMethod("AddOne"));
var encoded = EncodedExpression.EncodeExpression(expected);
encoded.Values["Method"] = encoded.Values["Method"].Replace("AddOne", "MissingOne");
Assert.Throws <MethodNotFoundException>(() => EncodedExpression.DecodeExpression(encoded));
}
public void Lambda()
{
Expression <Func <int> > expected = () => 3 + 3;
var encoded = EncodedExpression.EncodeExpression(expected);
var actual = (Expression <Func <int> >)EncodedExpression.DecodeExpression(encoded);
Assert.AreEqual(expected.ToString(), actual.ToString());
Assert.AreEqual(expected.Compile().Invoke(), actual.Compile().Invoke());
Assert.AreEqual(6, actual.Compile().Invoke());
}
public void DecodeUnsafeStaticMethodIsError()
{
var expected = Expression.Call(typeof(MethodCallTest).GetMethod("GetOne"));
var encoded = EncodedExpression.EncodeExpression(expected);
var exception = Assert.Throws <UnsafeMethodCallException>(() => EncodedExpression.DecodeExpression(encoded));
Assert.IsNotNull(exception.MethodInfo);
Assert.AreEqual(nameof(MethodCallTest.GetOne), exception.MethodInfo.Name);
}
public void DecodeUnsafeInstanceMethodIsError()
{
var parameterExpr = Expression.Parameter(typeof(MethodCallTest), "a");
var expected = Expression.Call(parameterExpr, typeof(MethodCallTest).GetMethod("AddOne"));
var encoded = EncodedExpression.EncodeExpression(expected);
var exception = Assert.Throws <UnsafeMethodCallException>(() => EncodedExpression.DecodeExpression(encoded));
Assert.IsNotNull(exception.MethodInfo);
Assert.AreEqual(nameof(MethodCallTest.AddOne), exception.MethodInfo.Name);
}
public void ConvertChecked()
{
var expected = Expression.ConvertChecked(Expression.Constant(6), typeof(byte));
var encoded = EncodedExpression.EncodeExpression(expected);
var actual = EncodedExpression.DecodeExpression(encoded);
Assert.AreEqual(expected.ToString(), actual.ToString());
var expectedLambda = Expression.Lambda <Func <byte> >(expected);
var actualLambda = Expression.Lambda <Func <byte> >(actual);
Assert.AreEqual(expectedLambda.Compile().Invoke(), actualLambda.Compile().Invoke());
Assert.AreEqual(( byte )6, actualLambda.Compile().Invoke());
}
public void Not()
{
var expected = Expression.Not(Expression.Constant(false));
var encoded = EncodedExpression.EncodeExpression(expected);
var actual = EncodedExpression.DecodeExpression(encoded);
Assert.AreEqual(expected.ToString(), actual.ToString());
var expectedLambda = Expression.Lambda <Func <bool> >(expected);
var actualLambda = Expression.Lambda <Func <bool> >(actual);
Assert.AreEqual(expectedLambda.Compile().Invoke(), actualLambda.Compile().Invoke());
Assert.AreEqual(true, actualLambda.Compile().Invoke());
}
public void NegateChecked()
{
var expected = Expression.NegateChecked(Expression.Constant(3));
var encoded = EncodedExpression.EncodeExpression(expected);
var actual = EncodedExpression.DecodeExpression(encoded);
Assert.AreEqual(expected.ToString(), actual.ToString());
var expectedLambda = Expression.Lambda <Func <int> >(expected);
var actualLambda = Expression.Lambda <Func <int> >(actual);
Assert.AreEqual(expectedLambda.Compile().Invoke(), actualLambda.Compile().Invoke());
Assert.AreEqual(-3, actualLambda.Compile().Invoke());
}
public void ConvertChecked_Overflow()
{
var expected = Expression.ConvertChecked(Expression.Constant(600), typeof(byte));
var encoded = EncodedExpression.EncodeExpression(expected);
var actual = EncodedExpression.DecodeExpression(encoded);
Assert.AreEqual(expected.ToString(), actual.ToString());
var expectedLambda = Expression.Lambda <Func <byte> >(expected);
var actualLambda = Expression.Lambda <Func <byte> >(actual);
Assert.Throws(typeof(OverflowException), () => expectedLambda.Compile().Invoke());
Assert.Throws(typeof(OverflowException), () => actualLambda.Compile().Invoke());
}
public void OnesComplement()
{
var expected = Expression.OnesComplement(Expression.Constant(127));
var encoded = EncodedExpression.EncodeExpression(expected);
var actual = EncodedExpression.DecodeExpression(encoded);
Assert.AreEqual(expected.ToString(), actual.ToString());
var expectedLambda = Expression.Lambda <Func <int> >(expected);
var actualLambda = Expression.Lambda <Func <int> >(actual);
Assert.AreEqual(expectedLambda.Compile().Invoke(), actualLambda.Compile().Invoke());
Assert.AreEqual(-128, actualLambda.Compile().Invoke());
}
public void CallSafeStaticMethod()
{
Expression <Func <int> > expected = () => MethodCallTest.GetOne();
var encoded = EncodedExpression.EncodeExpression(expected);
var decodeOptions = new DecodeOptions();
decodeOptions.SafeStaticMethodTypes.Add(typeof(MethodCallTest));
var actual = (Expression <Func <int> >)EncodedExpression.DecodeExpression(encoded, decodeOptions);
Assert.AreEqual(expected.ToString(), actual.ToString());
Assert.AreEqual(1, expected.Compile().Invoke());
}
public void NewtonsoftEncodeSystemJsonDecode()
{
Expression <Func <int> > expected = () => 3 + 3;
var encoded = EncodedExpression.EncodeExpression(expected);
var json = Newtonsoft.Json.JsonConvert.SerializeObject(encoded);
var jsonEncoded = System.Text.Json.JsonSerializer.Deserialize <EncodedExpression>(json);
var actual = (Expression <Func <int> >)EncodedExpression.DecodeExpression(jsonEncoded);
Assert.AreEqual(expected.ToString(), actual.ToString());
Assert.AreEqual(expected.Compile().Invoke(), actual.Compile().Invoke());
Assert.AreEqual(6, actual.Compile().Invoke());
}
public void MemberAccessProperty()
{
var testObject = new TestHelper
{
PropertyValue = 6
};
var objExpr = Expression.Parameter(typeof(TestHelper), "p");
var expected = Expression.Property(objExpr, "PropertyValue");
var expectedLambda = Expression.Lambda <Func <TestHelper, int> >(expected, objExpr);
var encoded = EncodedExpression.EncodeExpression(expectedLambda);
var actualLambda = (Expression <Func <TestHelper, int> >)EncodedExpression.DecodeExpression(encoded);
Assert.AreEqual(expectedLambda.ToString(), actualLambda.ToString());
Assert.AreEqual(expectedLambda.Compile().Invoke(testObject), actualLambda.Compile().Invoke(testObject));
Assert.AreEqual(6, actualLambda.Compile().Invoke(testObject));
}
public void CallTwoParameterMethod()
{
Expression <Func <MethodCallTest, int> > expected = (a) => a.AddValues(1, 2);
var encoded = EncodedExpression.EncodeExpression(expected);
var decodeOptions = new DecodeOptions
{
AllowUnsafeCalls = true
};
var actual = (Expression <Func <MethodCallTest, int> >)EncodedExpression.DecodeExpression(encoded, decodeOptions);
Assert.AreEqual(expected.ToString(), actual.ToString());
var testObject = new MethodCallTest();
Assert.AreEqual(3, expected.Compile().Invoke(testObject));
testObject = new MethodCallTest();
Assert.AreEqual(3, actual.Compile().Invoke(testObject));
}
public void CallSafeMethod()
{
Expression <Action <MethodCallTest> > expected = (a) => a.AddOne();
var encoded = EncodedExpression.EncodeExpression(expected);
var decodeOptions = new DecodeOptions();
decodeOptions.SafeMethods.Add(typeof(MethodCallTest).GetMethod(nameof(MethodCallTest.AddOne)));
var actual = (Expression <Action <MethodCallTest> >)EncodedExpression.DecodeExpression(encoded, decodeOptions);
Assert.AreEqual(expected.ToString(), actual.ToString());
var testObject = new MethodCallTest();
expected.Compile().Invoke(testObject);
Assert.AreEqual(1, testObject.Value);
testObject = new MethodCallTest();
actual.Compile().Invoke(testObject);
Assert.AreEqual(1, testObject.Value);
}