public void ChokesOnCircularReferenceToPlaceHolder() { RootObjectDefinition def = new RootObjectDefinition(); def.ObjectType = typeof(TestObject); ConstructorArgumentValues args = new ConstructorArgumentValues(); args.AddNamedArgumentValue("name", "${foo}"); def.ConstructorArgumentValues = args; NameValueCollection properties = new NameValueCollection(); const string expectedName = "ba${foo}r"; properties.Add("foo", expectedName); IConfigurableListableObjectFactory mock = mocks.StrictMock <IConfigurableListableObjectFactory>(); Expect.Call(mock.GetObjectDefinitionNames(false)).Return(new string[] { "foo" }); Expect.Call(mock.GetObjectDefinition(null, false)).IgnoreArguments().Return(def); mocks.ReplayAll(); PropertyPlaceholderConfigurer cfg = new PropertyPlaceholderConfigurer(); cfg.Properties = properties; try { cfg.PostProcessObjectFactory(mock); Assert.Fail("Should have raised an ObjectDefinitionStoreException by this point."); } catch (ObjectDefinitionStoreException) { } mocks.VerifyAll(); }
public void UsingCustomMarkers() { RootObjectDefinition def = new RootObjectDefinition(); def.ObjectType = typeof(TestObject); ConstructorArgumentValues args = new ConstructorArgumentValues(); args.AddNamedArgumentValue("name", "#hope.floats#"); def.ConstructorArgumentValues = args; NameValueCollection properties = new NameValueCollection(); const string expectedName = "Rick"; properties.Add("hope.floats", expectedName); IConfigurableListableObjectFactory mock = mocks.StrictMock <IConfigurableListableObjectFactory>(); Expect.Call(mock.GetObjectDefinitionNames(false)).Return(new string[] { "foo" }); Expect.Call(mock.GetObjectDefinition(null, false)).IgnoreArguments().Return(def); Expect.Call(() => mock.AddEmbeddedValueResolver(null)).IgnoreArguments(); mocks.ReplayAll(); PropertyPlaceholderConfigurer cfg = new PropertyPlaceholderConfigurer(); cfg.PlaceholderPrefix = cfg.PlaceholderSuffix = "#"; cfg.Properties = properties; cfg.PostProcessObjectFactory(mock); mocks.VerifyAll(); Assert.AreEqual(expectedName, def.ConstructorArgumentValues.GetNamedArgumentValue("name").Value, "Named argument placeholder value was not replaced."); }
public void ValueHolderToStringsNicely() { ConstructorArgumentValues values = new ConstructorArgumentValues(); values.AddGenericArgumentValue(1, typeof(int).FullName); ConstructorArgumentValues.ValueHolder vh = values.GetGenericArgumentValue(typeof(int)); Assert.AreEqual("'1' [System.Int32]", vh.ToString()); }
public void AddGenericArgumentValue() { ConstructorArgumentValues values = new ConstructorArgumentValues(); values.AddGenericArgumentValue(DBNull.Value); Assert.IsFalse(values.Empty, "Added one value, but the collection is sayin' it's empty."); Assert.AreEqual(1, values.ArgumentCount, "Added one value, but the collection ain't sayin' that it's got a single element in it."); Assert.AreEqual(1, values.GenericArgumentValues.Count, "Added one generic value, but the collection of indexed values ain't sayin' that it's got a single element in it."); }
public void Instantiation() { ConstructorArgumentValues values = new ConstructorArgumentValues(); Assert.IsNotNull(values.GenericArgumentValues, "The 'GenericArgumentValues' property was not initialised."); Assert.IsNotNull(values.IndexedArgumentValues, "The 'IndexedArgumentValues' property was not initialised."); Assert.IsNotNull(values.NamedArgumentValues, "The 'NamedArgumentValues' property was not initialised."); Assert.AreEqual(0, values.ArgumentCount, "There were some arguments in a newly initialised instance."); Assert.IsTrue(values.Empty, "A newly initialised instance was not initially empty."); }
public void AddNamedArgument() { ConstructorArgumentValues values = new ConstructorArgumentValues(); values.AddNamedArgumentValue("foo", "sball"); Assert.AreEqual(1, values.NamedArgumentValues.Count, "Added one named argument but it doesn't seem to have been added to the named arguments collection."); Assert.AreEqual(1, values.ArgumentCount, "Added one named argument but it doesn't seem to be reflected in the overall argument count."); ConstructorArgumentValues.ValueHolder arg = values.GetNamedArgumentValue("foo"); Assert.IsNotNull(arg, "The named argument previously added could not be pulled from the ctor arg collection."); Assert.AreEqual("sball", arg.Value, "The value of the named argument passed in is not the same as the one that was pulled out."); }
public void AddRangeOfIndexedArgumentValues() { ConstructorArgumentValues values = new ConstructorArgumentValues(); values.AddIndexedArgumentValue(1, DBNull.Value); values.AddIndexedArgumentValue(2, "Foo"); values.AddIndexedArgumentValue(3, 3); new ConstructorArgumentValues(values); Assert.IsFalse(values.Empty, "Added three indexed values(as a range), but the collection is sayin' it's empty."); Assert.AreEqual(3, values.ArgumentCount, "Added three indexed values(as a range), but the collection ain't sayin' that it's got 3 elements in it."); Assert.AreEqual(3, values.IndexedArgumentValues.Count, "Added three indexed values(as a range), but the collection of indexed values ain't sayin' that it's got 3 elements in it."); }
public void GetGeneric_Untyped_ArgumentValue() { ConstructorArgumentValues values = new ConstructorArgumentValues(); const string expectedValue = "Rick"; values.AddGenericArgumentValue(expectedValue); ConstructorArgumentValues.ValueHolder name = values.GetGenericArgumentValue(null, null); Assert.IsNotNull(name, "Must get non-null valueholder back if no required type is specified."); Assert.AreEqual(expectedValue, name.Value); }
public void GetGenericArgumentValue() { ConstructorArgumentValues values = new ConstructorArgumentValues(); Assert.IsNull(values.GetGenericArgumentValue(typeof(object)), "Mmm... managed to get a non null instance back from an empty instance."); values.AddGenericArgumentValue(DBNull.Value, typeof(DBNull).FullName); Assert.IsNull(values.GetGenericArgumentValue(typeof(string)), "Mmm... managed to get a non null instance back from an instance that should have now't with the specified Type."); ConstructorArgumentValues.ValueHolder value = values.GetGenericArgumentValue(typeof(DBNull)); Assert.IsNotNull(value, "Stored a value of a specified Type, but got null when retrieving it using said Type."); Assert.AreSame(DBNull.Value, value.Value, "The value stored at the specified index was not the exact same instance as was added."); }
public void GetGeneric_Untyped_ArgumentValueWithOnlyStronglyTypedValuesInTheCtorValueList() { ConstructorArgumentValues values = new ConstructorArgumentValues(); const string expectedValue = "Rick"; values.AddGenericArgumentValue(expectedValue, typeof(string).FullName); ConstructorArgumentValues.ValueHolder name = values.GetGenericArgumentValue(null, null); Assert.IsNull(name, "Must get null valueholder back if no required type is specified but only " + "strongly typed values are present in the ctor values list."); }
public void NamedArgumentsAreCaseInsensitive() { ConstructorArgumentValues values = new ConstructorArgumentValues(); values.AddNamedArgumentValue("foo", "sball"); Assert.AreEqual(1, values.NamedArgumentValues.Count, "Added one named argument but it doesn't seem to have been added to the named arguments collection."); Assert.AreEqual(1, values.ArgumentCount, "Added one named argument but it doesn't seem to be reflected in the overall argument count."); Assert.IsTrue(values.ContainsNamedArgument("FOo"), "Mmm, the ContainsNamedArgument() method eveidently IS case sensitive (which is wrong)."); ConstructorArgumentValues.ValueHolder arg = values.GetNamedArgumentValue("fOo"); Assert.IsNotNull(arg, "The named argument previously added could not be pulled from the ctor arg collection."); Assert.AreEqual("sball", arg.Value, "The value of the named argument passed in is not the same as the one that was pulled out."); }
public void AddAllFromOther() { ConstructorArgumentValues other = new ConstructorArgumentValues(); other.AddIndexedArgumentValue(1, DBNull.Value); other.AddIndexedArgumentValue(2, "Foo"); other.AddIndexedArgumentValue(3, 3); ConstructorArgumentValues values = new ConstructorArgumentValues(); values.AddAll(other); Assert.AreEqual(other.ArgumentCount, values.ArgumentCount, "Must have been the same since one was filled up with the values in the other."); }
/// <summary> /// Traverse the given ObjectDefinition object and the MutablePropertyValues /// and ConstructorArgumentValues contained in them. /// </summary> /// <param name="definition">The object definition to traverse.</param> public virtual void VisitObjectDefinition(IObjectDefinition definition) { VisitObjectTypeName(definition); VisitPropertyValues(definition); ConstructorArgumentValues cas = definition.ConstructorArgumentValues; if (cas != null) { VisitIndexedArgumentValues(cas.IndexedArgumentValues); VisitNamedArgumentValues(cas.NamedArgumentValues); VisitGenericArgumentValues(cas.GenericArgumentValues); } }
public void GetIndexedArgumentValue() { ConstructorArgumentValues values = new ConstructorArgumentValues(); Assert.IsNull(values.GetIndexedArgumentValue(0, typeof(object)), "Mmm... managed to get a non null instance back from an empty instance."); values.AddIndexedArgumentValue(16, DBNull.Value, typeof(DBNull).FullName); Assert.IsNull(values.GetIndexedArgumentValue(0, typeof(object)), "Mmm... managed to get a non null instance back from an instance that should have now't at the specified index."); ConstructorArgumentValues.ValueHolder value = values.GetIndexedArgumentValue(16, typeof(DBNull)); Assert.IsNotNull(value, "Stored a value at a specified index, but got null when retrieving it."); Assert.AreSame(DBNull.Value, value.Value, "The value stored at the specified index was not the exact same instance as was added."); ConstructorArgumentValues.ValueHolder wrongValue = values.GetIndexedArgumentValue(16, typeof(string)); Assert.IsNull(wrongValue, "Stored a value at a specified index, and got it (or rather something) back when retrieving it with the wrong Type specified."); }
public void GetArgumentValue() { ConstructorArgumentValues values = new ConstructorArgumentValues(); Assert.IsNull(values.GetArgumentValue(0, typeof(object)), "Mmm... managed to get a non null instance back from an empty instance."); values.AddGenericArgumentValue(DBNull.Value, typeof(DBNull).FullName); values.AddNamedArgumentValue("foo", DBNull.Value); values.AddIndexedArgumentValue(16, DBNull.Value, typeof(DBNull).FullName); Assert.IsNull(values.GetArgumentValue(100, typeof(string)), "Mmm... managed to get a non null instance back from an instance that should have now't with the specified Type."); ConstructorArgumentValues.ValueHolder value = values.GetArgumentValue(-3, typeof(DBNull)); Assert.IsNotNull(value, "Stored a value of a specified Type at a specified index, but got null when retrieving it using the wrong index but the correct Type."); Assert.AreSame(DBNull.Value, value.Value, "The retrieved value was not the exact same instance as was added."); value = values.GetArgumentValue("foo", typeof(DBNull)); Assert.IsNotNull(value, "Stored a value of a specified Type under a name, but got null when retrieving it using the wrong name but the correct Type."); Assert.AreSame(DBNull.Value, value.Value, "The retrieved value was not the exact same instance as was added."); }
/// <summary> /// Copy all given argument values into this object. /// </summary> /// <param name="other"> /// The <see cref="Oragon.Spring.Objects.Factory.Config.ConstructorArgumentValues"/> /// to be used to populate this instance. /// </param> public void AddAll(ConstructorArgumentValues other) { if (other != null) { foreach (ValueHolder o in other.GenericArgumentValues) { GenericArgumentValues.Add(o); } foreach (KeyValuePair <int, ValueHolder> entry in other.IndexedArgumentValues) { ValueHolder vh = entry.Value; if (vh != null) { AddOrMergeIndexedArgumentValues(entry.Key, vh.Copy()); } } foreach (KeyValuePair <string, object> entry in other.NamedArgumentValues) { AddOrMergeNamedArgumentValues(entry.Key, entry.Value); //NamedArgumentValues.Add(entry.Key, entry.Value); } } }
public void GetGenericArgumentValueIgnoresAlreadyUsedValues() { ISet used = new ListSet(); ConstructorArgumentValues values = new ConstructorArgumentValues(); values.AddGenericArgumentValue(1); values.AddGenericArgumentValue(2); values.AddGenericArgumentValue(3); Type intType = typeof(int); ConstructorArgumentValues.ValueHolder one = values.GetGenericArgumentValue(intType, used); Assert.AreEqual(1, one.Value); used.Add(one); ConstructorArgumentValues.ValueHolder two = values.GetGenericArgumentValue(intType, used); Assert.AreEqual(2, two.Value); used.Add(two); ConstructorArgumentValues.ValueHolder three = values.GetGenericArgumentValue(intType, used); Assert.AreEqual(3, three.Value); used.Add(three); ConstructorArgumentValues.ValueHolder four = values.GetGenericArgumentValue(intType, used); Assert.IsNull(four); }
/// <summary> /// Creates a new instance of the /// <see cref="Oragon.Spring.Objects.Factory.Config.ConstructorArgumentValues"/> /// class. /// </summary> /// <param name="other"> /// The <see cref="Oragon.Spring.Objects.Factory.Config.ConstructorArgumentValues"/> /// to be used to populate this instance. /// </param> public ConstructorArgumentValues(ConstructorArgumentValues other) { AddAll(other); }
public void AddNamedArgumentWithEmptyStringName() { ConstructorArgumentValues values = new ConstructorArgumentValues(); Assert.Throws <ArgumentNullException>(() => values.AddNamedArgumentValue(string.Empty, 1)); }
public void AddNamedArgumentWithWhitespaceStringName() { ConstructorArgumentValues values = new ConstructorArgumentValues(); Assert.Throws <ArgumentNullException>(() => values.AddNamedArgumentValue(Environment.NewLine + " ", 1)); }
public void SunnyDay() { StaticApplicationContext ac = new StaticApplicationContext(); MutablePropertyValues pvs = new MutablePropertyValues(); pvs.Add("age", "${age}"); RootObjectDefinition def = new RootObjectDefinition("${fqn}", new ConstructorArgumentValues(), pvs); ac.RegisterObjectDefinition("tb3", def); pvs = new MutablePropertyValues(); pvs.Add("age", "${age}"); pvs.Add("name", "name${var}${"); pvs.Add("spouse", new RuntimeObjectReference("${ref}")); ac.RegisterSingleton("tb1", typeof(TestObject), pvs); ConstructorArgumentValues cas = new ConstructorArgumentValues(); cas.AddIndexedArgumentValue(1, "${age}"); cas.AddGenericArgumentValue("${var}name${age}"); pvs = new MutablePropertyValues(); ArrayList friends = new ManagedList(); friends.Add("na${age}me"); friends.Add(new RuntimeObjectReference("${ref}")); pvs.Add("friends", friends); ISet someSet = new ManagedSet(); someSet.Add("na${age}me"); someSet.Add(new RuntimeObjectReference("${ref}")); pvs.Add("someSet", someSet); IDictionary someDictionary = new ManagedDictionary(); someDictionary["key1"] = new RuntimeObjectReference("${ref}"); someDictionary["key2"] = "${age}name"; MutablePropertyValues innerPvs = new MutablePropertyValues(); someDictionary["key3"] = new RootObjectDefinition(typeof(TestObject), innerPvs); someDictionary["key4"] = new ChildObjectDefinition("tb1", innerPvs); pvs.Add("someMap", someDictionary); RootObjectDefinition definition = new RootObjectDefinition(typeof(TestObject), cas, pvs); ac.DefaultListableObjectFactory.RegisterObjectDefinition("tb2", definition); pvs = new MutablePropertyValues(); pvs.Add("Properties", "<spring-config><add key=\"age\" value=\"98\"/><add key=\"var\" value=\"${m}var\"/><add key=\"ref\" value=\"tb2\"/><add key=\"m\" value=\"my\"/><add key=\"fqn\" value=\"Oragon.Spring.Objects.TestObject, Oragon.Spring.Core.Tests\"/></spring-config>"); ac.RegisterSingleton("configurer", typeof(PropertyPlaceholderConfigurer), pvs); ac.Refresh(); TestObject tb1 = (TestObject)ac.GetObject("tb1"); TestObject tb2 = (TestObject)ac.GetObject("tb2"); TestObject tb3 = (TestObject)ac.GetObject("tb3"); Assert.AreEqual(98, tb1.Age); Assert.AreEqual(98, tb2.Age); Assert.AreEqual(98, tb3.Age); Assert.AreEqual("namemyvar${", tb1.Name); Assert.AreEqual("myvarname98", tb2.Name); Assert.AreEqual(tb2, tb1.Spouse); Assert.AreEqual(2, tb2.Friends.Count); IEnumerator ie = tb2.Friends.GetEnumerator(); ie.MoveNext(); Assert.AreEqual("na98me", ie.Current); ie.MoveNext(); Assert.AreEqual(tb2, ie.Current); Assert.AreEqual(2, tb2.SomeSet.Count); Assert.IsTrue(tb2.SomeSet.Contains("na98me")); Assert.IsTrue(tb2.SomeSet.Contains(tb2)); Assert.AreEqual(4, tb2.SomeMap.Count); Assert.AreEqual(tb2, tb2.SomeMap["key1"]); Assert.AreEqual("98name", tb2.SomeMap["key2"]); TestObject inner1 = (TestObject)tb2.SomeMap["key3"]; TestObject inner2 = (TestObject)tb2.SomeMap["key4"]; Assert.AreEqual(0, inner1.Age); Assert.AreEqual(null, inner1.Name); Assert.AreEqual(98, inner2.Age); Assert.AreEqual("namemyvar${", inner2.Name); }
public void AddAllDoesntChokeOnNullArgument() { ConstructorArgumentValues values = new ConstructorArgumentValues(); values.AddAll(null); }
public void AddNamedArgumentWithNullName() { ConstructorArgumentValues values = new ConstructorArgumentValues(); Assert.Throws <ArgumentNullException>(() => values.AddNamedArgumentValue(null, 1)); }