public void EncodeExpression_UnsupportedNodeType()
{
var sdi = Expression.SymbolDocument("test.xml");
var debugInfo = Expression.DebugInfo(sdi, 1, 1, 2, 2);
Assert.Throws <ArgumentException>(() => EncodedExpression.EncodeExpression(debugInfo));
}
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 IsAnonymousType_GenericPass()
{
var anonObject = new List <string>();
var objExpr = Expression.Parameter(anonObject.GetType(), "p");
var expected = Expression.Property(objExpr, "Count");
Assert.DoesNotThrow(() => EncodedExpression.EncodeExpression(expected));
}
public void IsAnonymousType_Fail()
{
var anonObject = new { Value = 4 };
var objExpr = Expression.Parameter(anonObject.GetType(), "p");
var expected = Expression.Property(objExpr, "Value");
var ex = Assert.Throws <Exception>(() => EncodedExpression.EncodeExpression(expected));
Assert.AreEqual("Encoding member access of anonymous types is not supported.", ex.Message);
}
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_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 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 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 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()
{
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());
}
/// <summary>
/// Gets the <see cref="ParameterExpression"/> associated with the parameter.
/// </summary>
/// <param name="parameter">The encoded parameter.</param>
/// <returns>A <see cref="ParameterExpression"/> instance.</returns>
public ParameterExpression GetOrAddParameter(EncodedExpression parameter)
{
var guid = Guid.Parse(parameter.Values["Guid"]);
if (!_parameters.ContainsKey(guid))
{
var type = ( string )parameter.Values["Type"];
var name = ( string )parameter.Values["Name"];
_parameters.Add(guid, Expression.Parameter(SignatureHelper.GetTypeFromSignature(type), name));
}
return(_parameters[guid]);
}
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));
}
/// <summary>
/// Gets the <see cref="EncodedExpression"/> associated with the name.
/// </summary>
/// <param name="parameter">The parameter.</param>
/// <returns>A <see cref="EncodedExpression"/> instance.</returns>
public EncodedExpression GetOrAddParameter(ParameterExpression parameter)
{
if (!_parameters.ContainsKey(parameter))
{
var p = new EncodedExpression
{
NodeType = ExpressionType.Parameter,
Values = new Dictionary <string, string>
{
{ "Type", SignatureHelper.GetSignatureFromType(parameter.Type) },
{ "Name", parameter.Name },
{ "Guid", Guid.NewGuid().ToString() }
}
};
_parameters.Add(parameter, p);
}
return(_parameters[parameter]);
}
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);
}
