polishing

switch ObjectDefinitionValueResolver & related infrastructure code from using RootObjectDefinition to IObjectDefinition
fixed SPRNET-1073
added PropertyOrFieldNode tests for injecting transparent proxies
added new CollectionUtils.FindValuesOfType() method for filtering collections

test/Spring/Spring.Core.Tests/Expressions/PropertyOrFieldNodeTests.cs

@@ -1,7 +1,7 @@
 #region License
 
 /*
- * Copyright <20> 2002-2008 the original author or authors.
+ * Copyright <20> 2002-2009 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,12 +18,9 @@
 
 #endregion
 
-#region Imports
-
 using System;
 using NUnit.Framework;
-
-#endregion
+using Spring.Objects;
 
 namespace Spring.Expressions
 {
@@ -31,13 +28,15 @@ namespace Spring.Expressions
     /// Tests the behavior of PropertyOrFieldNode expression node
     /// </summary>
     /// <author>Erich Eichinger</author>
-    /// <version>$Id: $</version>
     [TestFixture]
     public class PropertyOrFieldNodeTests
     {
         private class BaseClass
         {
+            private ITestObject objectProp;
+
             public string StringProp { get { return "BaseStringProp"; }}
+            public ITestObject ObjectProp { get { return objectProp; } set { objectProp = value; } }
         }
 
         private class DerivedClass : BaseClass
@@ -54,5 +53,21 @@ namespace Spring.Expressions
 
             Assert.AreEqual(new DateTime(2008,1,1), ((IExpression) pofNode).GetValue(new DerivedClass()));
         }
+
+        [Test]
+        public void CanSetTransparentProxy()
+        {
+            PropertyOrFieldNode pofNode = new PropertyOrFieldNode();
+            pofNode.Text = "ObjectProp";
+
+            BaseClass ouc = new BaseClass();
+            TestTransparentProxyFactory tpf = new TestTransparentProxyFactory(null, typeof(ITestObject), null);
+            object tpo = tpf.GetTransparentProxy();
+            Assert.IsTrue( tpo is ITestObject );
+            ITestObject itpo = tpo as ITestObject;
+            Assert.IsNotNull(itpo);
+            pofNode.SetValue( ouc, null, itpo);
+            Assert.AreSame( tpo, ouc.ObjectProp );
+        }
     }
 }

test/Spring/Spring.Core.Tests/Objects/Factory/Support/ManagedDictionaryTests.cs

@@ -23,6 +23,8 @@ using System.Collections;
 using NUnit.Framework;
 #if NET_2_0
 using System.Collections.Generic;
+using Spring.Objects.Factory.Config;
+
 #endif
 
 namespace Spring.Objects.Factory.Support
@@ -48,7 +50,7 @@ namespace Spring.Objects.Factory.Support
             dict2.ValueTypeName = typeof(InternalType).FullName;
 
             IDictionary resolved = (IDictionary) dict2.Resolve("other", new RootObjectDefinition(typeof (object)), "prop",
-                                                               delegate(string name, RootObjectDefinition definition, string argumentName, object element)
+                                                               delegate(string name, IObjectDefinition definition, string argumentName, object element)
                                                                    {
                                                                        if ("stringValue".Equals(element))
                                                                        {
@@ -69,7 +71,7 @@ namespace Spring.Objects.Factory.Support
 
             dict.ValueTypeName = "System.Collections.Generic.List<[string]>";
             IDictionary resolved = (IDictionary) dict.Resolve("somename", new RootObjectDefinition(typeof(object)), "prop",
-                                                              delegate(string name, RootObjectDefinition definition, string argumentName, object element)
+                                                              delegate(string name, IObjectDefinition definition, string argumentName, object element)
                                                                   {
                                                                       if ("value".Equals(element))
                                                                       {

test/Spring/Spring.Core.Tests/Objects/TestTransparentProxyFactory.cs

@@ -0,0 +1,114 @@
+#region License
+
+/*
+ * Copyright 2002-2009 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#endregion
+
+using System;
+using System.Reflection;
+using System.Runtime.Remoting;
+using System.Runtime.Remoting.Messaging;
+using System.Runtime.Remoting.Proxies;
+
+namespace Spring.Objects
+{
+    /// <summary>
+    /// </summary>
+    /// <author>Erich Eichinger</author>
+    public class TestTransparentProxyFactory : RealProxy, IRemotingTypeInfo
+    {
+        public delegate object InvokeCallback(object proxy, object targetInstance, MethodInfo targetMethod, object[] arguments);
+
+        private object targetInstance;
+        private Type targetType;
+        private InvokeCallback invokeHandler;
+
+        public object TargetInstance
+        {
+            get { return targetInstance; }
+            set { targetInstance = value; }
+        }
+
+        public Type TargetType
+        {
+            get { return targetType; }
+            set { targetType = value; }
+        }
+
+        public InvokeCallback InvokeHandler
+        {
+            get { return invokeHandler; }
+            set { invokeHandler = value; }
+        }
+
+        public TestTransparentProxyFactory(object targetInstance, Type targetType, InvokeCallback invokeHandler)
+            : base(typeof(MarshalByRefObject))
+        {
+            this.targetInstance = targetInstance;
+            this.targetType = targetType;
+            this.invokeHandler = invokeHandler;
+        }
+
+        public override IMessage Invoke(IMessage msg)
+        {
+            if (msg is IMethodCallMessage)
+            {
+                IMethodCallMessage callMsg = (IMethodCallMessage)msg;
+
+                // obtain method with same name & signature from target instance
+                MethodInfo targetMethod = targetInstance.GetType().GetMethod(callMsg.MethodName, (Type[])callMsg.MethodSignature);
+
+                // invoke
+                object result;
+                if (invokeHandler != null)
+                {
+                    result = invokeHandler(this, targetInstance, targetMethod, callMsg.Args);
+                }
+                else
+                {
+                    result = targetMethod.Invoke(targetInstance, callMsg.Args);
+                }
+
+                // create result msg
+                return new ReturnMessage(result, null, 0, null, callMsg);
+            }
+            throw new NotSupportedException();
+        }
+
+        public virtual bool CanCastTo(Type fromType, object o)
+        {
+            // we accept ALL messages...
+            return fromType.IsAssignableFrom(fromType);
+        }
+
+        public virtual string TypeName
+        {
+            get { return targetInstance.GetType().AssemblyQualifiedName; }
+            set { throw new System.NotSupportedException(); }
+        }
+
+        public static TestTransparentProxyFactory GetProxy(object transparentProxy )
+        {
+            return (TestTransparentProxyFactory) RemotingServices.GetRealProxy(transparentProxy);
+        }
+
+        public static object GetTargetInstance( object transparentProxy )
+        {
+            return GetProxy(transparentProxy).targetInstance;
+        }
+    }
+}

test/Spring/Spring.Core.Tests/Spring.Core.Tests.2008.csproj

@@ -630,6 +630,7 @@
     <Compile Include="Objects\TestObjectList.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="Objects\TestTransparentProxyFactory.cs" />
     <Compile Include="Objects\TypeMismatchExceptionTests.cs">
       <SubType>Code</SubType>
     </Compile>