public void private_reference_property_on_private_object()
        {
            var assemblyName = Assembly.GetExecutingAssembly().FullName;
            var typeName     = "NewRelic.Reflection.UnitTests.PublicOuter+PrivateInner";
            var propertyName = "PrivateInnerProperty";
            var privateInner = PublicOuter.CreatePrivateInner();

            var methodCaller = VisibilityBypasser.Instance.GeneratePropertyAccessor <object>(assemblyName, typeName, propertyName);
            var actualValue  = methodCaller(privateInner);

            Assert.NotNull(actualValue);
        }
        public void private_value_property_on_private_object()
        {
            var assemblyName  = Assembly.GetExecutingAssembly().FullName;
            var typeName      = "NewRelic.Reflection.UnitTests.PublicOuter+PrivateInner";
            var propertyName  = "Int32Property";
            var expectedValue = 11;
            var privateInner  = PublicOuter.CreatePrivateInner();

            var methodCaller = VisibilityBypasser.Instance.GeneratePropertyAccessor <int>(assemblyName, typeName, propertyName);
            var actualValue  = methodCaller(privateInner);

            Assert.AreEqual(expectedValue, actualValue);
        }
        public void private_value_returning_method_on_private_object()
        {
            var assemblyName  = Assembly.GetExecutingAssembly().FullName;
            var typeName      = "NewRelic.Reflection.UnitTests.PublicOuter+PrivateInner";
            var methodName    = "Int32ReturningMethod";
            var expectedValue = 5;
            var privateInner  = PublicOuter.CreatePrivateInner();

            var methodCaller = VisibilityBypasser.Instance.GenerateParameterlessMethodCaller <int>(assemblyName, typeName, methodName);
            var actualValue  = methodCaller(privateInner);

            Assert.AreEqual(expectedValue, actualValue);
        }
        public void private_int32_on_private_object()
        {
            var assemblyName  = Assembly.GetExecutingAssembly().FullName;
            var typeName      = "NewRelic.Reflection.UnitTests.PublicOuter+PrivateInner";
            var fieldName     = "_int32Field";
            var privateInner  = PublicOuter.CreatePrivateInner();
            var expectedValue = 3;

            var fieldAccessor = VisibilityBypasser.Instance.GenerateFieldReadAccessor <int>(assemblyName, typeName, fieldName);
            var actualValue   = fieldAccessor(privateInner);

            Assert.AreEqual(expectedValue, actualValue);
        }
示例#5
0
        public void set_private_value_property_on_private_object()
        {
            var assemblyName = Assembly.GetExecutingAssembly().FullName;
            var typeName     = "NewRelic.Reflection.UnitTests.PublicOuter+PrivateInner";
            var propertyName = "Int32Property";
            var privateInner = PublicOuter.CreatePrivateInner();

            var getter        = VisibilityBypasser.Instance.GeneratePropertyAccessor <int>(assemblyName, typeName, propertyName);
            var originalValue = getter(privateInner);

            var setter = VisibilityBypasser.Instance.GeneratePropertySetter <int>(privateInner, propertyName);

            setter(originalValue + 1);

            var newValue = getter(privateInner);

            Assert.AreEqual(newValue, originalValue + 1);
        }
示例#6
0
        public void set_private_reference_property_on_private_object()
        {
            var assemblyName = Assembly.GetExecutingAssembly().FullName;
            var typeName     = "NewRelic.Reflection.UnitTests.PublicOuter+PrivateInner";
            var propertyName = "DictionaryProperty";
            var privateInner = PublicOuter.CreatePrivateInner();

            var getter        = VisibilityBypasser.Instance.GeneratePropertyAccessor <object>(assemblyName, typeName, propertyName);
            var originalValue = getter(privateInner);

            var setter = VisibilityBypasser.Instance.GeneratePropertySetter <Dictionary <string, object> >(privateInner, propertyName);

            setter(new Dictionary <string, object>()
            {
                { "newKey", "newValue" }
            });

            var newValue = (Dictionary <string, object>)getter(privateInner);

            Assert.AreNotSame(originalValue, newValue);
            Assert.That((string)newValue["newKey"] == "newValue");
        }