public void TestEquals() { PropertyValue one = new PropertyValue("Age", 12); PropertyValue two = new PropertyValue("Age", 12); Assert.AreEqual(one, two); Assert.AreEqual(one.GetHashCode(), two.GetHashCode()); Assert.AreEqual(one, one); Assert.IsFalse(one.Equals("Foo")); }
public void ChangesSince() { IDictionary map = new Hashtable (); PropertyValue propName = new PropertyValue ("Name", "Fiona Apple"); map.Add (propName.Name, propName.Value); map.Add ("Age", 24); MutablePropertyValues props = new MutablePropertyValues (map); MutablePropertyValues newProps = new MutablePropertyValues (map); // change the name... this is the change we'll be looking for newProps.SetPropertyValueAt (new PropertyValue (propName.Name, "Naomi Woolf"), 0); IPropertyValues changes = newProps.ChangesSince (props); Assert.AreEqual (1, changes.PropertyValues.Length); // the name was changed, so its the name property that should be in the changed list Assert.IsTrue (changes.Contains ("name")); newProps.Add (new PropertyValue ("Commentator", "Naomi Woolf")); changes = newProps.ChangesSince (props); Assert.AreEqual (2, changes.PropertyValues.Length); // the Commentator was added, so its the Commentator property that should be in the changed list Assert.IsTrue (changes.Contains ("commentator")); // the name was changed, so its the name property that should be in the changed list Assert.IsTrue (changes.Contains ("name")); }
public void TestToString() { PropertyValue one = new PropertyValue("Age", 12); Assert.AreEqual("PropertyValue: name='Age'; value=[12].", one.ToString()); }
public void Instantiation() { PropertyValue val = new PropertyValue("Age", 12); Assert.AreEqual("Age", val.Name); Assert.AreEqual(12, val.Value); }
public void RemoveByPropertyValue () { MutablePropertyValues props = new MutablePropertyValues (); PropertyValue propName = new PropertyValue ("Name", "Fiona Apple"); props.Add (propName); props.Add (new PropertyValue ("Age", 24)); Assert.AreEqual (2, props.PropertyValues.Count); props.Remove (propName); Assert.AreEqual (1, props.PropertyValues.Count); }
/// <summary> /// Merges the value of the supplied 'new' <see cref="PropertyValue"/> with that of /// the current <see cref="PropertyValue"/> if merging is supported and enabled. /// </summary> /// <see cref="IMergable"/> /// <param name="newPv">The new pv.</param> /// <param name="currentPv">The current pv.</param> /// <returns>The possibly merged PropertyValue</returns> private PropertyValue MergeIfRequired(PropertyValue newPv, PropertyValue currentPv) { object val = newPv.Value; IMergable mergable = val as IMergable; if (mergable != null) { if (mergable.MergeEnabled) { object merged = mergable.Merge(currentPv.Value); return new PropertyValue(newPv.Name, merged); } } return newPv; }
/// <summary> /// Modify a <see cref="Spring.Objects.PropertyValue"/> object held in this object. Indexed from 0. /// </summary> public void SetPropertyValueAt(PropertyValue pv, int i) { propertyValuesList [i] = pv; }
/// <summary> /// Remove the given <see cref="Spring.Objects.PropertyValue"/>, if contained. /// </summary> /// <param name="pv"> /// The <see cref="Spring.Objects.PropertyValue"/> to remove. /// </param> public void Remove(PropertyValue pv) { propertyValuesList.Remove (pv); }
/// <summary> /// Add the supplied <see cref="Spring.Objects.PropertyValue"/> object, /// replacing any existing one for the respective property. /// </summary> /// <param name="pv"> /// The <see cref="Spring.Objects.PropertyValue"/> object to add. /// </param> public void Add(PropertyValue pv) { for (int i = 0; i < propertyValuesList.Count; ++i) { PropertyValue currentPv = (PropertyValue) propertyValuesList [i]; if (currentPv.Name.Equals (pv.Name)) { pv = MergeIfRequired(pv, currentPv); propertyValuesList[i] = pv; return ; } } propertyValuesList.Add (pv); }
/// <summary> /// Apply the given property values, resolving any runtime references /// to other objects in this object factory. /// </summary> /// <param name="name"> /// The object name passed for better exception information. /// </param> /// <param name="definition"> /// The definition of the named object. /// </param> /// <param name="wrapper"> /// The <see cref="Spring.Objects.IObjectWrapper"/> wrapping the target object. /// </param> /// <param name="properties"> /// The new property values. /// </param> /// <remarks> /// <p> /// Must use deep copy, so that we don't permanently modify this property. /// </p> /// </remarks> protected void ApplyPropertyValues(string name, RootObjectDefinition definition, IObjectWrapper wrapper, IPropertyValues properties) { if (properties == null || properties.PropertyValues.Length == 0) { return; } ObjectDefinitionValueResolver valueResolver = CreateValueResolver(); MutablePropertyValues deepCopy = new MutablePropertyValues(properties); PropertyValue[] copiedProperties = deepCopy.PropertyValues; for (int i = 0; i < copiedProperties.Length; ++i) { PropertyValue copiedProperty = copiedProperties[i]; //(string name, RootObjectDefinition definition, string argumentName, object argumentValue) object value = valueResolver.ResolveValueIfNecessary(name, definition, copiedProperty.Name, copiedProperty.Value); // object value = ResolveValueIfNecessary(name, definition, copiedProperty.Name, copiedProperty.Value); PropertyValue propertyValue = new PropertyValue(copiedProperty.Name, value, copiedProperty.Expression); // update mutable copy... deepCopy.SetPropertyValueAt(propertyValue, i); } // set the (possibly resolved) deep copy properties... try { wrapper.SetPropertyValues(deepCopy); } catch (ObjectsException ex) { // improve the message by showing the context... throw new ObjectCreationException(definition.ResourceDescription, name, "Error setting property values: " + ex.Message, ex); } }
/// <summary> /// Sets a property value. /// </summary> /// <remarks> /// <p> /// <b>This is the preferred way to update an individual property.</b> /// </p> /// </remarks> /// <param name="pv"> /// The object containing new property value. /// </param> public virtual void SetPropertyValue(PropertyValue pv) { SetPropertyValue(pv.Expression, pv.Value); }