[Springnet-commits] Spring.Net/test/Spring/Spring.Core.Tests/Objects/Support ArgumentConvertingMethodInvokerTests.cs,NONE,1.1 MethodParametersCountCriteriaTests.cs,NONE,1.1 InstanceEventHandlerValueTests.cs,1.2,1.3 PropertyComparatorTests.cs,1.2,1.3

[Springboy <spr...@us...>]

Update of /cvsroot/springnet/Spring.Net/test/Spring/Spring.Core.Tests/Objects/Support
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv12801/test/Spring/Spring.Core.Tests/Objects/Support

Modified Files:
	InstanceEventHandlerValueTests.cs PropertyComparatorTests.cs 
Added Files:
	ArgumentConvertingMethodInvokerTests.cs 
	MethodParametersCountCriteriaTests.cs 
Log Message:
Initial Import...

Index: InstanceEventHandlerValueTests.cs
===================================================================
RCS file: /cvsroot/springnet/Spring.Net/test/Spring/Spring.Core.Tests/Objects/Support/InstanceEventHandlerValueTests.cs,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** InstanceEventHandlerValueTests.cs	22 Sep 2004 08:41:39 -0000	1.2
--- InstanceEventHandlerValueTests.cs	28 Sep 2004 08:30:56 -0000	1.3
***************
*** 59,62 ****
--- 59,73 ----
              wirer.Wire (source, typeof (StaticPingListener));
          }
+ 
+         [Test]
+         [ExpectedException (typeof (FatalObjectException))]
+         public void BailsIfMethodDoesntExist () 
+         {
+             PingSource source = new PingSource ();
+             InstanceEventHandlerValue wirer
+                 = new InstanceEventHandlerValue (source, "Roo");
+             wirer.EventName = "Ping";
+             wirer.Wire (source, typeof (StaticPingListener));
+         }
  	}
  }

--- NEW FILE: ArgumentConvertingMethodInvokerTests.cs ---
#region Licence

/*
 * Copyright 2004 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

#region Imports

using System;

using NUnit.Framework;

#endregion

namespace Spring.Objects.Support
{
	/// <summary>
	/// Unit tests for the ArgumentConvertingMethodInvoker class.
    /// </summary>
    /// <author>Rick Evans</author>
    /// <version>$Id: ArgumentConvertingMethodInvokerTests.cs,v 1.1 2004/09/28 08:30:56 springboy Exp $</version>
	[TestFixture]
    public sealed class ArgumentConvertingMethodInvokerTests
    {
        [Test]
        public void Invoke () {
            ArgumentConvertingMethodInvoker vkr = new ArgumentConvertingMethodInvoker ();
            vkr.TargetObject = new Voker ();
            vkr.TargetMethod = "Hi";
            vkr.Arguments = new object [] {"Rick, Mark, Griffin, Si, Choy, Aleks"};
            vkr.Prepare ();
            string actual = vkr.Invoke () as string;
            Assert.IsNotNull (actual);
            Assert.AreEqual ("Hi Rick, Mark, Griffin, Si, Choy, Aleks", actual);
        }

        [Test]
        public void InvokeWithConversion () 
        {
            ArgumentConvertingMethodInvoker vkr = new ArgumentConvertingMethodInvoker ();
            Voker instance = new Voker ();
            vkr.TargetObject = instance;
            vkr.TargetMethod = "HiEverybody";
            // CSV string should be converted to string []
            vkr.Arguments = new object [] {"Rick, Mark, Griffin, Si, Choy, Aleks"};
            vkr.Prepare ();
            string actual = vkr.Invoke () as string;
            Assert.IsNotNull (actual);
            Assert.AreEqual ("Hi ya'll", actual);
            Assert.IsNotNull (instance.developers);
        }

        [Test]
        public void InvokeWithRegisteredConversion () 
        {
            ArgumentConvertingMethodInvoker vkr = new ArgumentConvertingMethodInvoker ();
            // see if custom registration filters thru...
            vkr.RegisterCustomConverter (typeof (Voker), new VokerConverter ());
            vkr.TargetType = typeof (Voker);
            vkr.TargetMethod = "HiVoker";
            // arg should be converted to Voker
            vkr.Arguments = new object [] {"Lebowski"};
            vkr.Prepare ();
            string actual = vkr.Invoke () as string;
            Assert.IsNotNull (actual);
            Assert.AreEqual ("Hi Lebowski", actual);
        }
    }

    public sealed class Voker 
    {
        public Voker () : this ("HiroProtagonist") {}

        public Voker (string name) 
        {
            this.name = name;
        }

        public string Hi (string name)
        {
            return "Hi " + name;
        }

        public string HiEverybody (string [] names)
        {
            developers = names;
            return "Hi ya'll";
        }

        public static string HiVoker (Voker buddy) 
        {
            return "Hi " + buddy.name;
        }

        public string [] developers;
        public string name;
    }

    public sealed class VokerConverter : System.ComponentModel.TypeConverter 
    {
        public override bool CanConvertFrom (
            System.ComponentModel.ITypeDescriptorContext context, Type sourceType)
        {
            if (sourceType == typeof (string)) 
            {
                return true;
            }
            return base.CanConvertFrom (context, sourceType);
        }

        public override object ConvertFrom (
            System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
        {
            if (value is string) 
            {
                return new Voker (value as string);
            }
            return base.ConvertFrom (context, culture, value);
        }
    }
}

Index: PropertyComparatorTests.cs
===================================================================
RCS file: /cvsroot/springnet/Spring.Net/test/Spring/Spring.Core.Tests/Objects/Support/PropertyComparatorTests.cs,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** PropertyComparatorTests.cs	22 Sep 2004 08:41:39 -0000	1.2
--- PropertyComparatorTests.cs	28 Sep 2004 08:30:56 -0000	1.3
***************
*** 130,133 ****
--- 130,149 ----
  
          [Test]
+         [Ignore ("Sort ordering is not preserved (unstable) with equal elements (c.f. System.Array.Sort (Array, IComparer)))")]
+         public void OrderingIsUnperturbedWithEqualProps () 
+         {
+             TestObject one = new TestObject ("Rick", 19);
+             TestObject two = new TestObject ("Balzac", 19);
+             TestObject three = new TestObject ("Jenny", 19);
+             TestObject [] actual = new TestObject [] {one, two, three};
+             TestObject [] expected = new TestObject [] {one /*Rick*/, two /*Balzac*/, three /*Jenny*/};
+             PropertyComparator.Sort (actual, new MySortDefinition ("age", false, false));
+             for (int i = 0; i < actual.Length; ++i) 
+             {
+                 Assert.AreEqual (expected [i].Name, actual [i].Name);
+             }
+         }
+ 
+         [Test]
          [ExpectedException (typeof (ArgumentNullException))]
          public void SortWithNullDefinition () 
***************
*** 136,139 ****
--- 152,170 ----
          }
  
+         [Test]
+         [Ignore ("Sort ordering is not preserved (unstable) with equal elements (c.f. System.Array.Sort (Array, IComparer)))")]
+         public void SortWithNonComparableTypes () 
+         {
+             Funk one = new Funk ("1");
+             Funk two = new Funk ("2");
+             Funk three = new Funk ("3");
+             Funk [] actual = new Funk [] {one, three, two};
+             PropertyComparator.Sort (actual, new MySortDefinition ("Nails", true, false));
+             // ordering should be unperturbed...
+             Assert.AreEqual (one.Id, actual [2].Id);
+             Assert.AreEqual (three.Id, actual [1].Id);
+             Assert.AreEqual (two.Id, actual [0].Id);
+         }
+ 
          internal sealed class MySortDefinition : ISortDefinition 
          {
***************
*** 175,178 ****
--- 206,244 ----
              private bool _ascending;
          }
+ 
+         internal sealed class Funk 
+         {
+             public Funk (string id) 
+             {
+                 Id = id;
+             }
+ 
+             private Nails _nails = new Nails ();
+             private string _id;
+ 
+             public Nails Nails 
+             {
+                 get 
+                 {
+                     return _nails;
+                 }
+             }
+ 
+             public string Id 
+             {
+                 get 
+                 {
+                     return _id;
+                 }
+                 set 
+                 {
+                     _id = value;
+                 }
+             }
+         }
+ 
+         internal sealed class Nails 
+         {
+         }
      }
  }

--- NEW FILE: MethodParametersCountCriteriaTests.cs ---
#region Licence

/*
 * Copyright 2004 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

#region Imports

using System;
using System.Reflection;

using NUnit.Framework;

#endregion

namespace Spring.Objects.Support
{
	/// <summary>
	/// Unit tests for the MethodParametersCountCriteria class.
    /// </summary>
    /// <author>Rick Evans</author>
    /// <version>$Id: MethodParametersCountCriteriaTests.cs,v 1.1 2004/09/28 08:30:56 springboy Exp $</version>
	[TestFixture]
    public sealed class MethodParametersCountCriteriaTests
    {
        [Test]
        public void Instantiation () {
            MethodParametersCountCriteria criteria = new MethodParametersCountCriteria ();
            Assert.AreEqual (0, criteria.ExpectedParameterCount);
            criteria = new MethodParametersCountCriteria (10);
            Assert.AreEqual (10, criteria.ExpectedParameterCount);
        }

        [Test]
        [ExpectedException (typeof (ArgumentOutOfRangeException))]
        public void InstantiationBailsWithParameterCountSetToLessThanZero () 
        {
            MethodParametersCountCriteria criteria = new MethodParametersCountCriteria (-10);
        }

        [Test]
        [ExpectedException (typeof (ArgumentOutOfRangeException))]
        public void BailsWhenExpectedParameterCountSetToLessThanZero () 
        {
            MethodParametersCountCriteria criteria = new MethodParametersCountCriteria ();
            criteria.ExpectedParameterCount = -12;
        }

        [Test]
        public void IsSatisfied () 
        {
            MethodParametersCountCriteria criteria = new MethodParametersCountCriteria ();
            MethodInfo method = GetType ().GetMethod ("NoParameter", BindingFlags.Public | BindingFlags.Instance);
            Assert.IsTrue (criteria.IsSatisfied (method));

            criteria = new MethodParametersCountCriteria (1);
            method = GetType ().GetMethod ("OneParameter", BindingFlags.Public | BindingFlags.Instance);
            Assert.IsTrue (criteria.IsSatisfied (method));

            criteria = new MethodParametersCountCriteria (2);
            method = GetType ().GetMethod ("TwoParameters", BindingFlags.Public | BindingFlags.Instance);
            Assert.IsTrue (criteria.IsSatisfied (method));
        }

        [Test]
        public void IsNotSatisfiedWithNull () 
        {
            MethodParametersCountCriteria criteria = new MethodParametersCountCriteria ();
            Assert.IsFalse (criteria.IsSatisfied (null));
        }

        public void NoParameter () 
        {
        }

        public void OneParameter (int foo) 
        {
        }

        public void TwoParameters (int foo, int bar) 
        {
        }
	}
}