Test coverage for partial trust environments

Author: SteveWilkes

ReadableExpressions.UnitTests/ReadableExpressions.UnitTests.csproj

@@ -60,6 +60,7 @@
     <Compile Include="..\VersionInfo.cs">
       <Link>VersionInfo.cs</Link>
     </Compile>
+    <Compile Include="WhenUsingPartialTrust.cs" />
     <Compile Include="WhenTranslatingStringConcatenation.cs" />
     <Compile Include="WhenTranslatingComments.cs" />
     <Compile Include="WhenTranslatingDynamicOperations.cs" />

ReadableExpressions.UnitTests/WhenUsingPartialTrust.cs

@@ -0,0 +1,142 @@
+namespace AgileObjects.ReadableExpressions.UnitTests
+{
+    using System;
+    using System.Linq.Expressions;
+    using System.Security;
+    using System.Security.Policy;
+    using Microsoft.CSharp.RuntimeBinder;
+    using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+    [TestClass]
+    public class WhenUsingPartialTrust
+    {
+        [TestMethod]
+        public void ShouldTranslateASimpleAssignment()
+        {
+            ExecuteInPartialTrust(helper =>
+            {
+                var translated = helper.TranslateSimpleAssignment();
+
+                Assert.AreEqual("i = 0", translated);
+            });
+        }
+
+        [TestMethod]
+        public void ShouldTranslateADynamicExpression()
+        {
+            ExecuteInPartialTrust(helper =>
+            {
+                var translated = helper.TranslateDynamicExpression();
+
+                Assert.AreEqual("obj => obj.Length", translated);
+            });
+        }
+
+        [TestMethod]
+        public void ShouldTranslateAValueTypeTypeEqualExpression()
+        {
+            ExecuteInPartialTrust(helper =>
+            {
+                var translated = helper.TranslateIntTypeEqualExpression();
+
+                Assert.AreEqual("(i TypeOf typeof(long))", translated);
+            });
+        }
+
+        [TestMethod]
+        public void ShouldTranslateAnObjectTypeEqualExpression()
+        {
+            ExecuteInPartialTrust(helper =>
+            {
+                var translated = helper.TranslateObjectTypeEqualExpression();
+
+                Assert.AreEqual("(o is string)", translated);
+            });
+        }
+
+        private static void ExecuteInPartialTrust(Action<TranslationHelper> testAction)
+        {
+            AppDomain partialTrustDomain = null;
+
+            try
+            {
+                var evidence = new Evidence();
+                evidence.AddHostEvidence(new Zone(SecurityZone.Internet));
+
+                var permissions = new NamedPermissionSet(
+                    "PartialTrust",
+                    SecurityManager.GetStandardSandbox(evidence));
+
+                partialTrustDomain = AppDomain.CreateDomain(
+                    "PartialTrust",
+                    evidence,
+                    new AppDomainSetup { ApplicationBase = "." },
+                    permissions);
+
+                var helperType = typeof(TranslationHelper);
+
+                var helper = (TranslationHelper)partialTrustDomain
+                    .CreateInstanceAndUnwrap(helperType.Assembly.FullName, helperType.FullName);
+
+                testAction.Invoke(helper);
+            }
+            finally
+            {
+                if (partialTrustDomain != null)
+                {
+                    AppDomain.Unload(partialTrustDomain);
+                }
+            }
+        }
+    }
+
+    public class TranslationHelper : MarshalByRefObject
+    {
+        public string TranslateSimpleAssignment()
+        {
+            var intVariable = Expression.Variable(typeof(int), "i");
+            var assignment = Expression.Assign(intVariable, Expression.Constant(0));
+
+            return assignment.ToReadableString();
+        }
+
+        public string TranslateDynamicExpression()
+        {
+            var lengthGetterSiteBinder = Binder.GetMember(
+                CSharpBinderFlags.None,
+                "Length",
+                typeof(WhenTranslatingDynamicOperations),
+                new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) });
+
+            var dynamicParameter = Expression.Parameter(typeof(object), "obj");
+
+            var dynamicLengthGetter = Expression.Dynamic(
+                lengthGetterSiteBinder,
+                typeof(object),
+                dynamicParameter);
+
+            var dynamicLengthLambda = Expression
+                .Lambda<Func<object, object>>(dynamicLengthGetter, dynamicParameter);
+
+            dynamicLengthLambda.Compile();
+
+            return dynamicLengthLambda.ToReadableString();
+        }
+
+        public string TranslateIntTypeEqualExpression()
+        {
+            var intVariable = Expression.Variable(typeof(int), "i");
+            var intIsLong = Expression.TypeEqual(intVariable, typeof(long));
+
+            return intIsLong.ToReadableString();
+        }
+
+        public string TranslateObjectTypeEqualExpression()
+        {
+            var objectVariable = Expression.Variable(typeof(object), "o");
+            var objectIsString = Expression.TypeEqual(objectVariable, typeof(string));
+
+            return objectIsString.ToReadableString();
+        }
+    }
+}

ReadableExpressions/Translators/TypeEqualExpressionTranslator.cs

@@ -36,7 +36,18 @@ public override string Translate(Expression expression, TranslationContext conte
                 return FallbackTranslation(expression, context);
             }
 
-            var reducedTypeEqualExpression = (Expression)_reduceTypeEqualMethod.Invoke(expression, null);
+            Expression reducedTypeEqualExpression;
+
+            try
+            {
+                reducedTypeEqualExpression = (Expression)_reduceTypeEqualMethod.Invoke(expression, null);
+            }
+            catch
+            {
+                // Unable to invoke the non-public ReduceTypeEqual method:
+                return FallbackTranslation(expression, context);
+            }
+
             var translated = context.Translate(reducedTypeEqualExpression).Unterminated();
 
             return translated;
@@ -47,7 +58,9 @@ private static string FallbackTranslation(Expression expression, TranslationCont
             var typeBinary = (TypeBinaryExpression)expression;
             var operand = context.Translate(typeBinary.Expression);
 
-            return $"({operand} TypeOf {typeBinary.TypeOperand.GetFriendlyName()})";
+            return typeBinary.TypeOperand.IsClass()
+                ? $"({operand} is {typeBinary.TypeOperand.GetFriendlyName()})"
+                : $"({operand} TypeOf typeof({typeBinary.TypeOperand.GetFriendlyName()}))";
         }
     }
 }