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