public void MultiplePatterns() { IObjectFactory iof = new XmlObjectFactory(new ReadOnlyXmlTestResource("RegularExpressionSetterTests.xml", GetType())); IPerson advised = (IPerson) iof.GetObject("SettersAndReturnsThisAdvised"); // Interceptor behind regexp advisor NopInterceptor nop = (NopInterceptor) iof.GetObject("NopInterceptor"); Assert.AreEqual(0, nop.Count); int newAge = 12; // Not advised advised.Exceptional(null); Assert.AreEqual(0, nop.Count); // This is proxied advised.ReturnsThis(); Assert.AreEqual(1, nop.Count); // Only setter is advised advised.SetAge(newAge); Assert.AreEqual(2, nop.Count); Assert.AreEqual(newAge, advised.GetAge()); Assert.AreEqual(2, nop.Count); }
public void RefSubelementsBuildCollectionWithPrototypes() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); TestObject jen = (TestObject)xof.GetObject("pJenny"); TestObject dave = (TestObject)xof.GetObject("pDavid"); TestObject rod = (TestObject)xof.GetObject("pRod"); IList friends = (IList)rod.Friends; Assert.IsTrue(friends.Count == 2); Assert.IsTrue(friends[0].ToString().Equals(jen.ToString()), "First friend must be jen, not " + friends[0]); Assert.IsTrue(friends[0] != jen, "Jen not same instance"); Assert.IsTrue(friends[1].ToString().Equals(dave.ToString())); Assert.IsTrue(friends[1] != dave, "Dave not same instance"); TestObject rod2 = (TestObject)xof.GetObject("pRod"); IList friends2 = (IList)rod2.Friends; Assert.IsTrue(friends2.Count == 2); Assert.IsTrue(friends2[0].ToString().Equals(jen.ToString()), "First friend must be jen, not " + friends2[0]); Assert.IsTrue(friends2[0] != friends[0], "Jen not same instance"); Assert.IsTrue(friends2[1].ToString().Equals(dave.ToString())); Assert.IsTrue(friends2[1] != friends[1], "Dave not same instance"); }
public void CustomListCollection() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); TestObject objectWithTypedFriends = (TestObject)xof.GetObject("objectWithTypedFriends"); TestObjectList tol = objectWithTypedFriends.TypedFriends; Assert.AreEqual(1, tol.Count); Assert.IsTrue(tol[0].Equals(xof.GetObject("david"))); }
public void ObjectArray() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); HasMap hasMap = (HasMap)xof.GetObject("objectArray"); Assert.IsTrue(hasMap.ObjectArray.Length == 2); Assert.IsTrue(hasMap.ObjectArray[0].Equals("one")); Assert.IsTrue(hasMap.ObjectArray[1].Equals(xof.GetObject("jenny"))); }
public void PopulatedSet() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); HasMap hasMap = (HasMap)xof.GetObject("set"); Assert.IsTrue(hasMap.Set.Count == 3); Assert.IsTrue(hasMap.Set.Contains("bar")); TestObject jenny = (TestObject)xof.GetObject("jenny"); Assert.IsTrue(hasMap.Set.Contains(jenny)); Assert.IsTrue(hasMap.Set.Contains(null)); }
public void SingletonProxyWithPrototypeTarget() { TestObjectImpl.constructionCount = 0; IObjectFactory iof = new XmlObjectFactory(new ReadOnlyXmlTestResource("prototypeTarget.xml", GetType())); for (int i = 0; i < 10; i++) { TestObject to = (TestObject) iof.GetObject("testObjectSingleton"); to.DoSomething(); } TestInterceptor interceptor = (TestInterceptor) iof.GetObject("testInterceptor"); Assert.AreEqual(1, TestObjectImpl.constructionCount); Assert.AreEqual(10, interceptor.invocationCount); }
public void MapWithLiteralsAndReferences() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); HasMap hasMap = (HasMap)xof.GetObject("mixedMap"); Assert.IsTrue(hasMap.Map.Count == 3); Assert.IsTrue(hasMap.Map["foo"].Equals("bar")); TestObject jenny = (TestObject)xof.GetObject("jenny"); Assert.IsTrue(hasMap.Map["jenny"] == jenny); Assert.IsTrue(hasMap.Map["david"].Equals("david")); }
public void AutoAliasing() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); IList <string> objectNames = xof.GetObjectDefinitionNames(); TestObject tb1 = (TestObject)xof.GetObject("aliased"); TestObject alias1 = (TestObject)xof.GetObject("myalias"); Assert.IsTrue(tb1 == alias1); IList <string> tb1Aliases = xof.GetAliases("aliased"); Assert.AreEqual(1, tb1Aliases.Count); Assert.IsTrue(tb1Aliases.Contains("myalias")); Assert.IsTrue(objectNames.Contains("aliased")); Assert.IsFalse(objectNames.Contains("myalias")); TestObject tb2 = (TestObject)xof.GetObject("multiAliased"); TestObject alias2 = (TestObject)xof.GetObject("alias1"); TestObject alias3 = (TestObject)xof.GetObject("alias2"); Assert.IsTrue(tb2 == alias2); Assert.IsTrue(tb2 == alias3); IList <string> tb2Aliases = xof.GetAliases("multiAliased"); Assert.AreEqual(2, tb2Aliases.Count); Assert.IsTrue(tb2Aliases.Contains("alias1")); Assert.IsTrue(tb2Aliases.Contains("alias2")); Assert.IsTrue(objectNames.Contains("multiAliased")); Assert.IsFalse(objectNames.Contains("alias1")); Assert.IsFalse(objectNames.Contains("alias2")); TestObject tb3 = (TestObject)xof.GetObject("aliasWithoutId1"); TestObject alias4 = (TestObject)xof.GetObject("aliasWithoutId2"); TestObject alias5 = (TestObject)xof.GetObject("aliasWithoutId3"); Assert.IsTrue(tb3 == alias4); Assert.IsTrue(tb3 == alias5); IList <string> tb3Aliases = xof.GetAliases("aliasWithoutId1"); Assert.AreEqual(2, tb2Aliases.Count); Assert.IsTrue(tb3Aliases.Contains("aliasWithoutId2")); Assert.IsTrue(tb3Aliases.Contains("aliasWithoutId3")); Assert.IsTrue(objectNames.Contains("aliasWithoutId1")); Assert.IsFalse(objectNames.Contains("aliasWithoutId2")); Assert.IsFalse(objectNames.Contains("aliasWithoutId3")); string className = typeof(TestObject).FullName; string targetName = className + ObjectDefinitionReaderUtils.GENERATED_OBJECT_NAME_SEPARATOR + "0"; TestObject tb4 = (TestObject)xof.GetObject(targetName); Assert.AreEqual(null, tb4.Name); }
public void SimpleCtor() { XmlObjectFactory xof = new XmlObjectFactory(new ReadOnlyXmlTestResource("simple-constructor-arg.xml", GetType())); ConstructorDependenciesObject obj = (ConstructorDependenciesObject)xof.GetObject("rod4"); Assert.AreEqual("Kerry2", obj.Spouse1.Name); }
/// <summary> /// Test that we can add elements to an ISet that is exposed as a /// read-only property /// </summary> public void AddElementsToReadOnlySet() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); TestObject to = (TestObject)xof.GetObject("readOnlySet"); ISet computers = to.Computers; Assert.IsTrue(computers.Count == 2); bool foundDell = false; bool foundIbm = false; foreach (string name in computers) { if (name.Equals("Dell")) { foundDell = true; } if (name.Equals("IBM T41")) { foundIbm = true; } } Assert.IsTrue(foundDell, "Dell string not found in ISet"); Assert.IsTrue(foundIbm, "IBM T41 not found in ISet"); }
public void EmptyValue() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); HasMap hasMap = (HasMap)xof.GetObject("emptyValue"); Assert.AreEqual("", hasMap.Props.Get("foo"), "Expected empty string"); }
public void EmptyProps() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); HasMap hasMap = (HasMap)xof.GetObject("emptyProps"); Assert.IsTrue(hasMap.Props.Count == 0); }
public void BuildCollectionFromMixtureOfReferencesAndValues() { MixedCollectionObject.ResetStaticState(); IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); MixedCollectionObject jumble = (MixedCollectionObject)xof.GetObject("jumble"); Assert.AreEqual(1, MixedCollectionObject.nrOfInstances); xof.GetObject("david", typeof(TestObject)); Assert.IsTrue(jumble.Jumble.Count == 4, "Expected 3 elements, not " + jumble.Jumble.Count); IList l = (IList)jumble.Jumble; Assert.IsTrue(l[0].Equals(xof.GetObject("david"))); Assert.IsTrue(l[1].Equals("literal")); Assert.IsTrue(l[2].Equals(xof.GetObject("jenny"))); Assert.IsTrue(l[3].Equals("rod")); }
public void ObjectWithIndexerProperty() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); TestObject testObject = (TestObject)xof.GetObject("objectWithIndexer"); Assert.IsNotNull(testObject); Assert.AreEqual("my string value", testObject[0]); }
public void MapWithLiteralsReferencesAndList() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); HasMap hasMap = (HasMap)xof.GetObject("mixedMapWithList"); Assert.IsTrue(hasMap.Map.Count == 4); Assert.IsTrue(hasMap.Map["foo"].Equals("bar")); TestObject jenny = (TestObject)xof.GetObject("jenny"); Assert.IsTrue(hasMap.Map["jenny"].Equals(jenny)); // Check list IList l = (IList)hasMap.Map["list"]; Assert.IsNotNull(l); Assert.IsTrue(l.Count == 4); Assert.IsTrue(l[0].Equals("zero")); Assert.IsTrue(l[3] == null); // Check nested map in list IDictionary m = (IDictionary)l[1]; Assert.IsNotNull(m); Assert.IsTrue(m.Count == 2); Assert.IsTrue(m["fo"].Equals("bar")); Assert.IsTrue(m["jen"].Equals(jenny), "Map element 'jenny' should be equal to jenny object, not " + m["jen"]); // Check nested list in list l = (IList)l[2]; Assert.IsNotNull(l); Assert.IsTrue(l.Count == 2); Assert.IsTrue(l[0].Equals(jenny)); Assert.IsTrue(l[1].Equals("ba")); // Check nested map m = (IDictionary)hasMap.Map["map"]; Assert.IsNotNull(m); Assert.IsTrue(m.Count == 2); Assert.IsTrue(m["foo"].Equals("bar")); Assert.IsTrue(m["jenny"].Equals(jenny), "Map element 'jenny' should be equal to jenny object, not " + m["jenny"]); }
public void PrototypeAndSingletonBehaveDifferently() { int initialCount = 10; IObjectFactory of = new XmlObjectFactory(new ReadOnlyXmlTestResource("prototypeTargetSourceTests.xml", GetType())); ISideEffectObject singleton = (ISideEffectObject)of.GetObject("singleton"); Assert.AreEqual(initialCount, singleton.Count); singleton.doWork(); Assert.AreEqual(initialCount + 1, singleton.Count); ISideEffectObject prototype = (ISideEffectObject)of.GetObject("prototype"); Assert.AreEqual(initialCount, prototype.Count); singleton.doWork(); Assert.AreEqual(initialCount, prototype.Count); ISideEffectObject prototypeByName = (ISideEffectObject)of.GetObject("prototypeByName"); Assert.AreEqual(initialCount, prototypeByName.Count); singleton.doWork(); Assert.AreEqual(initialCount, prototypeByName.Count); }
public void RefSubelementsBuildCollection() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); //Assert.IsTrue ("5 objects in reftypes, not " + xof.GetObjectDefinitionCount(), xof.GetObjectDefinitionCount() == 5); TestObject jen = (TestObject)xof.GetObject("jenny"); TestObject dave = (TestObject)xof.GetObject("david"); TestObject rod = (TestObject)xof.GetObject("rod"); // Must be a list to support ordering // Our object doesn't modify the collection: // of course it could be a different copy in a real object IList friends = (IList)rod.Friends; Assert.IsTrue(friends.Count == 2); Assert.IsTrue(friends[0] == jen, "First friend must be jen, not " + friends[0]); Assert.IsTrue(friends[1] == dave); // Should be ordered }
public void PrototypeDictionaryFactory() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); IDictionary map = (IDictionary)xof.GetObject("pMapFactory"); Assert.IsTrue(map.Count == 2); Assert.AreEqual("bar", map["foo"]); Assert.AreEqual("jenny", map["jen"]); }
public void TypedGenericDictionary() { XmlObjectFactory xof = new XmlObjectFactory(new ReadOnlyXmlTestResource("collections.xml", GetType())); GenericExpressionHolder obj = (GenericExpressionHolder)xof.GetObject("genericExpressionHolder"); Assert.AreEqual(2, obj["0"].GetValue()); Assert.AreEqual(8, obj["1"].GetValue()); Assert.AreEqual("ALEKSANDAR SEOVIC", obj["2"].GetValue()); Assert.IsTrue((bool)obj["3"].GetValue()); }
public void PopulatedProps() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); HasMap hasMap = (HasMap)xof.GetObject("props"); Assert.AreEqual(2, hasMap.Props.Count); Assert.AreEqual("bar", hasMap.Props["foo"]); Assert.AreEqual("TWO", hasMap.Props["2"]); }
public void TypedNonGenericList() { XmlObjectFactory xof = new XmlObjectFactory(new ReadOnlyXmlTestResource("collections.xml", GetType())); NonGenericExpressionHolder obj = (NonGenericExpressionHolder)xof.GetObject("nonGenericExpressionHolder"); Assert.AreEqual(2, obj[0].GetValue()); Assert.AreEqual(8, obj[1].GetValue()); Assert.AreEqual("ALEKSANDAR SEOVIC", obj[2].GetValue()); Assert.IsTrue((bool)obj[3].GetValue()); }
public void ClassArray() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); HasMap hasMap = (HasMap)xof.GetObject("classArray"); Assert.IsTrue(hasMap.ClassArray.Length == 2); Assert.IsTrue(hasMap.ClassArray[0].Equals(typeof(String))); Assert.IsTrue(hasMap.ClassArray[1].Equals(typeof(Exception))); }
public void MapWithLiteralsAndPrototypeReferences() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); TestObject jenny = (TestObject)xof.GetObject("pJenny"); HasMap hasMap = (HasMap)xof.GetObject("pMixedMap"); Assert.IsTrue(hasMap.Map.Count == 2); Assert.IsTrue(hasMap.Map["foo"].Equals("bar")); Assert.IsTrue(hasMap.Map["jenny"].ToString().Equals(jenny.ToString())); Assert.IsTrue(hasMap.Map["jenny"] != jenny, "Not same instance"); HasMap hasMap2 = (HasMap)xof.GetObject("pMixedMap"); Assert.IsTrue(hasMap2.Map.Count == 2); Assert.IsTrue(hasMap2.Map["foo"].Equals("bar")); Assert.IsTrue(hasMap2.Map["jenny"].ToString().Equals(jenny.ToString())); Assert.IsTrue(hasMap2.Map["jenny"] != hasMap.Map["jenny"], "Not same instance"); }
public void MapWithLiteralsOnly() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); HasMap hasMap = (HasMap)xof.GetObject("literalMap"); Assert.IsTrue(hasMap.Map.Count == 3); Assert.IsTrue(hasMap.Map["foo"].Equals("bar")); Assert.IsTrue(hasMap.Map["fi"].Equals("fum")); Assert.IsTrue(hasMap.Map["fa"] == null); }
public void RefSubelementsBuildCollectionFromSingleElement() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); TestObject loner = (TestObject)xof.GetObject("loner"); TestObject dave = (TestObject)xof.GetObject("david"); Assert.IsTrue(loner.Friends.Count == 1); bool contains = false; foreach (object friend in loner.Friends) { if (friend == dave) { contains = true; break; } } Assert.IsTrue(contains); }
public void DelimitedProps() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); HasMap hasMap = (HasMap)xof.GetObject("delimitedProps"); Assert.AreEqual(2, hasMap.Props.Count); Assert.AreEqual(3, hasMap.Props.GetValues("foo").Length); Assert.AreEqual(7, hasMap.Props.GetValues("days").Length); Assert.AreEqual("wednesday", hasMap.Props.GetValues("days")[2]); }
public void PrototypeSetFactory() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); Set mySet = (Set)xof.GetObject("pSetFactory"); Assert.IsTrue(mySet is HybridSet); Assert.IsTrue(mySet.Count == 2); Assert.IsTrue(mySet.Contains("bar")); Assert.IsTrue(mySet.Contains("jenny")); }
public void PrototypeListFactory() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); IList list = (IList)xof.GetObject("pListFactory"); Assert.IsTrue(list is LinkedList); Assert.IsTrue(list.Count == 2); Assert.AreEqual("bar", list[0]); Assert.AreEqual("jenny", list[1]); }
public void AddElementsToReadOnlyList() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); //Stream stream = new FileSystemResource("file:///w:/collections.xml").InputStream; XmlObjectFactory xof = new XmlObjectFactory(resource); TestObject aleks = (TestObject)xof.GetObject("aleks"); IList pets = (IList)aleks.Pets; Assert.IsTrue(pets.Count == 1); Assert.IsTrue(pets[0].Equals("Nadja")); }
public void CanApplyConstructorArgsToAbstractType() { IResource resource = new ReadOnlyXmlTestResource("ctor-args.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); TestObject rod = (TestObject)xof.GetObject("rod"); Assert.AreEqual(1, rod.Age); RootObjectDefinition def = (RootObjectDefinition) xof.GetObjectDefinition("rod"); ConstructorResolver resolver = new ConstructorResolver(xof, xof, new SimpleInstantiationStrategy(), new ObjectDefinitionValueResolver(xof)); ConstructorInstantiationInfo ci = resolver.GetConstructorInstantiationInfo("rod", def, null, null); AbstractObjectDefinition objDef = (AbstractObjectDefinition)xof.GetObjectDefinition("foo"); objDef.IsAbstract = false; TestObject foo = (TestObject) xof.GetObject("foo"); Assert.AreEqual(2, foo.Age); }
public void PopulatedPropsWithSameKey() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); HasMap hasMap = (HasMap)xof.GetObject("propsWithSameKey"); Assert.AreEqual(2, hasMap.Props.Count); Assert.AreEqual("OnE,tWo", hasMap.Props["foo"]); Assert.AreEqual(2, hasMap.Props.GetValues("bar").Length); Assert.AreEqual("OnE", hasMap.Props.GetValues("bar")[0]); Assert.AreEqual("tWo", hasMap.Props.GetValues("bar")[1]); }
/// <summary> /// Test that we can add elements to an IDictionary that is exposed as a /// read-only property. /// </summary> public void AddElementsToReadOnlyDictionary() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); TestObject to = (TestObject)xof.GetObject("readOnlyDictionary"); IDictionary table = to.PeriodicTable; Assert.IsTrue(table.Count == 2); Assert.AreEqual("1", table["hydrogen"], "Dictionary Value incorrect"); Assert.AreEqual("12", table["carbon"], "Dictionary value incorrect"); }
public void CreatesDbFactoryBean() { string xml = @"<?xml version='1.0' encoding='UTF-8' ?> <objects xmlns='http://www.springframework.net' xmlns:mongo='http://www.springframework.net/mongo'> <mongo:mongo url='mongodb://localhost' /> <mongo:db-factory id='first' mongo-ref='Mongo' write-concern='WMajority' /> </objects>"; var factory = new XmlObjectFactory(new StringResource(xml, Encoding.UTF8)); var mongoDatabase = factory.GetObject("first"); Assert.That(mongoDatabase, Is.Not.Null); }
public void ReadsReplicasWriteConcernCorrectly() { string xml = @"<?xml version='1.0' encoding='UTF-8' ?> <objects xmlns='http://www.springframework.net' xmlns:mongo='http://www.springframework.net/mongo'> <mongo:db-factory id='second' write-concern='W2' /> </objects>"; var factory = new XmlObjectFactory(new StringResource(xml, Encoding.UTF8)); var dbFactory = factory.GetObject<IMongoDatabaseFactory>("second"); var db = dbFactory.GetDatabase(); Assert.That(db.Settings.WriteConcern, Is.EqualTo(WriteConcern.W2)); }
public void GetDictionaryThatUsesNonStringKeys() { XmlObjectFactory xof = new XmlObjectFactory( new ReadOnlyXmlTestResource("collections.xml", GetType())); IDictionary map = (IDictionary)xof.GetObject("mapWithNonStringKeys"); Assert.AreEqual(2, map.Count); string v1 = (string)map[new TestObject("Rick Evans", 30)]; Assert.AreEqual("Rick Evans", v1); string v2 = (string)map[new TestObject("Uncle Elvis", 47)]; Assert.AreEqual("Elvis Orten", v2); }
public void CanApplyConstructorArgsToAbstractType() { IResource resource = new ReadOnlyXmlTestResource("ctor-args.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); TestObject rod = (TestObject)xof.GetObject("rod"); Assert.AreEqual(1, rod.Age); RootObjectDefinition def = (RootObjectDefinition)xof.GetObjectDefinition("rod"); ConstructorResolver resolver = new ConstructorResolver(xof, xof, new SimpleInstantiationStrategy(), new ObjectDefinitionValueResolver(xof)); ConstructorInstantiationInfo ci = resolver.GetConstructorInstantiationInfo("rod", def, null, null); AbstractObjectDefinition objDef = (AbstractObjectDefinition)xof.GetObjectDefinition("foo"); objDef.IsAbstract = false; TestObject foo = (TestObject)xof.GetObject("foo"); Assert.AreEqual(2, foo.Age); }
public void TestDifferentCollectionTypes() { const string xml = @"<?xml version='1.0' encoding='UTF-8' ?> <objects xmlns='http://www.springframework.net' xmlns:v='http://www.springframework.net/validation'> <v:group id='validatePerson' when='T(Spring.Objects.TestObject) == #this.GetType()'> <v:required id ='req' when='true' test='Name'/> <v:regex id ='reg' test='Name'> <v:property name='Expression' value='[a-z]*\s[a-z]*'/> <v:property name='Options' value='IgnoreCase'/> <v:message id='reg1' providers='regularni' when='true'> <v:param value='#this.ToString()'/> </v:message> </v:regex> </v:group> <v:collection id='collectionValidator' validate-all='true'> <v:ref name='validatePerson'/> </v:collection> </objects>"; MemoryStream stream = new MemoryStream(new UTF8Encoding().GetBytes(xml)); IResource resource = new InputStreamResource(stream, "collectionValidator"); XmlObjectFactory objectFactory = new XmlObjectFactory(resource, null); CollectionValidator validator = (CollectionValidator) objectFactory.GetObject("collectionValidator"); IList listPersons = new ArrayList(); IDictionary dictPersons = new Hashtable(); ISet setPersons = new ListSet(); listPersons.Add(new TestObject("DAMJAN Tomic", 24)); listPersons.Add(new TestObject("Goran Milosavljevic", 24)); listPersons.Add(new TestObject("Ivan CIKIC", 28)); dictPersons.Add(1, listPersons[0]); dictPersons.Add(2, listPersons[1]); dictPersons.Add(3, listPersons[2]); setPersons.AddAll(listPersons); IValidationErrors ve = new ValidationErrors(); Assert.IsTrue(validator.Validate(listPersons, ve)); Assert.IsTrue(ve.IsEmpty); Assert.IsTrue(validator.Validate(dictPersons, ve)); Assert.IsTrue(ve.IsEmpty); Assert.IsTrue(validator.Validate(setPersons, ve)); Assert.IsTrue(ve.IsEmpty); }
public void ISBNValidatorTests() { const string xml = @"<?xml version='1.0' encoding='UTF-8' ?> <objects xmlns='http://www.springframework.net' xmlns:v='http://www.springframework.net/validation'> <v:validator id='urlValidator' test='#this' type='Spring.Validation.Validators.UrlValidator, Spring.Core'/> </objects>"; MemoryStream stream = new MemoryStream(new UTF8Encoding().GetBytes(xml)); IResource resource = new InputStreamResource(stream, "urlValidator"); XmlObjectFactory objectFactory = new XmlObjectFactory(resource, null); object obj = objectFactory.GetObject("urlValidator"); Assert.IsTrue(obj is IValidator); IValidator validator = obj as IValidator; Assert.IsTrue(validator.Validate("http://www.springframework.net", new ValidationErrors())); }
public void DoesntCallContextRegistryForLocalObjectFactoryReferences() { string xml = string.Format( @"<?xml version='1.0' encoding='UTF-8' ?> <objects xmlns='http://www.springframework.net'> <object id='foo' type='{0}'> <property name='MyField' expression='@(theObject)' /> </object> </objects>" , typeof(MyTestObject).AssemblyQualifiedName ); XmlObjectFactory of = new XmlObjectFactory(new StringResource(xml, Encoding.UTF8)); object theObject = new object(); of.RegisterSingleton("theObject", theObject); MyTestObject to = (MyTestObject) of.GetObject("foo"); Assert.AreSame( theObject, to.MyField ); }
public void ISBNValidatorTests() { const string xml = @"<?xml version='1.0' encoding='UTF-8' ?> <objects xmlns='http://www.springframework.net' xmlns:v='http://www.springframework.net/validation'> <v:validator id='isbnValidator' test='#this' type='Spring.Validation.Validators.ISBNValidator, Spring.Core'> <v:message id='error.airportCode.dummy' providers='summary' when='false'/> </v:validator> </objects>"; MemoryStream stream = new MemoryStream(new UTF8Encoding().GetBytes(xml)); IResource resource = new InputStreamResource(stream, "isbnValidator"); XmlObjectFactory objectFactory = new XmlObjectFactory(resource, null); object obj = objectFactory.GetObject("isbnValidator"); Assert.IsTrue(obj is IValidator); IValidator validator = obj as IValidator; Assert.IsTrue(validator.Validate("978-1-905158-79-9", new ValidationErrors())); }
public void WithNullCardType() { const string xml = @"<?xml version='1.0' encoding='UTF-8' ?> <objects xmlns='http://www.springframework.net' xmlns:v='http://www.springframework.net/validation'> <v:validator id='ccValidator' test='#this' type='Spring.Validation.Validators.CreditCardValidator, Spring.Core'> <v:message id='error.airportCode.dummy' providers='summary' when='false'/> </v:validator> </objects>"; MemoryStream stream = new MemoryStream(new UTF8Encoding().GetBytes(xml)); IResource resource = new InputStreamResource(stream, "ccValidator"); XmlObjectFactory objectFactory = new XmlObjectFactory(resource, null); object obj = objectFactory.GetObject("ccValidator"); Assert.IsTrue(obj is CreditCardValidator); CreditCardValidator validator = obj as CreditCardValidator; Assert.IsNull(validator.CardType); Assert.IsTrue(validator.Validate("378282246310005", new ValidationErrors())); }
public void LocaleTest() { CultureInfo oldCulture = Thread.CurrentThread.CurrentCulture; try { Thread.CurrentThread.CurrentCulture = new CultureInfo("fr-FR"); IResource resource = new ReadOnlyXmlTestResource("locale.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); TestObject to = xof.GetObject("jenny") as TestObject; Assert.IsNotNull(to); DateTime d = new DateTime(2007, 10, 30); Assert.AreEqual(d, to.Date); Assert.AreEqual(30, to.Size.Height); Assert.AreEqual(30, to.Size.Width); } finally { Thread.CurrentThread.CurrentCulture = oldCulture; } }
public void AbstractParentObjects() { XmlObjectFactory parent = new XmlObjectFactory(new ReadOnlyXmlTestResource("parent.xml", GetType())); parent.PreInstantiateSingletons(); Assert.IsTrue(parent.IsSingleton("inheritedTestObjectWithoutClass")); // abstract objects should not match //TODO add overloaded GetObjectOfType with 1 arg IDictionary tbs = parent.GetObjectsOfType(typeof(TestObject), true, true); Assert.AreEqual(2, tbs.Count); Assert.IsTrue(tbs.Contains("inheritedTestObjectPrototype")); Assert.IsTrue(tbs.Contains("inheritedTestObjectSingleton")); // non-abstract object should work, even if it serves as parent object o1 = parent.GetObject("inheritedTestObjectPrototype"); Assert.IsTrue(o1 is TestObject); // abstract object should return IObjectInstance itself object o2 = parent.GetObject("inheritedTestObjectWithoutClass"); Assert.IsTrue(o2 is IObjectDefinition); }
public void DefaultDestroyMethodDisabled() { IResource resource = new ReadOnlyXmlTestResource("default-destroy-methods.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); xof.PreInstantiateSingletons(); DefaultDestroyer dd = (DefaultDestroyer)xof.GetObject("destroy-method2"); Assert.IsTrue(!dd.customDestroyed); xof.Dispose(); Assert.IsTrue(!dd.customDestroyed); }
public void FactoryReferenceCircle() { IResource resource = new ReadOnlyXmlTestResource("factoryCircle.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); TestObject tb = (TestObject) xof.GetObject("singletonFactory"); DummyFactory db = (DummyFactory) xof.GetObject("&singletonFactory"); Assert.IsTrue(tb == db.OtherTestObject); }
public void NoSuchInitMethod() { IResource resource = new ReadOnlyXmlTestResource("initializers.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); xof.GetObject("init-method3"); Assert.Fail(); }
public void InitializingObjectAndInitMethod() { InitAndIB.constructed = false; IResource resource = new ReadOnlyXmlTestResource("initializers.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); Assert.IsFalse(InitAndIB.constructed); xof.PreInstantiateSingletons(); Assert.IsFalse(InitAndIB.constructed); InitAndIB iib = (InitAndIB) xof.GetObject("init-and-ib"); Assert.IsTrue(InitAndIB.constructed); Assert.IsTrue(iib.afterPropertiesSetInvoked && iib.initMethodInvoked); Assert.IsTrue(!iib.destroyed && !iib.customDestroyed); xof.Dispose(); Assert.IsTrue(iib.destroyed && iib.customDestroyed); xof.Dispose(); Assert.IsTrue(iib.destroyed && iib.customDestroyed); }
public void DefaultInitMethodDisabled() { IResource resource = new ReadOnlyXmlTestResource("default-initializers.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); DoubleInitializer in_Renamed = (DoubleInitializer)xof.GetObject("init-method2"); // Initializer should have doubled value Assert.AreEqual(7, in_Renamed.Num); }
public void InitMethodThrowsException() { IResource resource = new ReadOnlyXmlTestResource("initializers.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); try { xof.GetObject("init-method2"); Assert.Fail(); } catch (ObjectCreationException ex) { Assert.IsTrue(ex.InnerException is FormatException); } }
public void BadParentReference() { IResource resource = new ReadOnlyXmlTestResource("wellformed-but-bad.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); xof.GetObject("no.parent.factory"); }
public void PropertyWithIdRefObjectAttrSubelement() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); TestObject verbose = (TestObject) xof.GetObject("verbose3"); Assert.IsTrue(verbose.Name.Equals("verbose")); }
public void SingletonInheritsFromParentFactoryPrototype() { XmlObjectFactory parent = new XmlObjectFactory(new ReadOnlyXmlTestResource("parent.xml", GetType())); XmlObjectFactory child = new XmlObjectFactory(new ReadOnlyXmlTestResource("child.xml", GetType()), parent); TestObject inherits = (TestObject) child.GetObject("singletonInheritsFromParentFactoryPrototype"); // Name property value is overriden Assert.IsTrue(inherits.Name.Equals("prototype-override")); // Age property is inherited from object in parent factory Assert.IsTrue(inherits.Age == 2); TestObject inherits2 = (TestObject) child.GetObject("singletonInheritsFromParentFactoryPrototype"); Assert.IsTrue(inherits2 == inherits); }
//SPRNET-1262 public void ProxiesDeclarativeAttributeWithConstructorArguments() { XmlObjectFactory objectFactory = null; const string xml = @"<?xml version='1.0' encoding='UTF-8' ?> <objects xmlns='http://www.springframework.net'> <object id='theService' type='Spring.ServiceModel.ServiceExporterTests+Service, Spring.Services.Tests'/> <object id='service' type='Spring.ServiceModel.ServiceExporter, Spring.Services'> <property name='TargetName' value='theService'/> <property name='TypeAttributes'> <list> <object type='System.ServiceModel.ServiceKnownTypeAttribute, System.ServiceModel' abstract='true'> <constructor-arg name='type' value='System.Collections.Generic.List<int>' /> </object> </list> </property> </object> </objects>"; using (Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(xml))) { objectFactory = new XmlObjectFactory(new InputStreamResource(stream, string.Empty)); } Type proxyType = (Type)objectFactory.GetObject("service"); object[] attrs = proxyType.GetCustomAttributes(false); ServiceKnownTypeAttribute attrib = null; //loop thru all retreived attributes, attempting to find the one that is of the expected type for (int i = 0; i < attrs.Length; i++) { attrib = attrs[i] as ServiceKnownTypeAttribute; //break out of the loop once we find the one we want if (attrib != null) break; } Assert.NotNull(attrib, String.Format("No attributes of the expecte type {0} were found.", typeof(ServiceKnownTypeAttribute))); Assert.AreEqual(typeof(List<int>), attrib.Type, "Property 'Type' on Target Attribute not set!"); }
public void BogusParentageFromParentFactory() { XmlObjectFactory parent = new XmlObjectFactory(new ReadOnlyXmlTestResource("parent.xml", GetType())); XmlObjectFactory child = new XmlObjectFactory(new ReadOnlyXmlTestResource("child.xml", GetType()), parent); child.GetObject("bogusParent"); }
public void ChildOverridesParentObject() { XmlObjectFactory parent = new XmlObjectFactory(new ReadOnlyXmlTestResource("parent.xml", GetType())); XmlObjectFactory child = new XmlObjectFactory(new ReadOnlyXmlTestResource("child.xml", GetType()), parent); TestObject inherits = (TestObject) child.GetObject("inheritedTestObject"); // Name property value is overridden Assert.IsTrue(inherits.Name.Equals("overrideParentObject")); // Age property is inherited from object in parent factory Assert.IsTrue(inherits.Age == 1); TestObject inherits2 = (TestObject) child.GetObject("inheritedTestObject"); Assert.IsTrue(inherits2 == inherits); }
public void DependenciesMaterializeThis() { IResource resource = new ReadOnlyXmlTestResource("dependenciesMaterializeThis.xml", GetType()); XmlObjectFactory bf = new XmlObjectFactory(resource); DummyBo bos = (DummyBo) bf.GetObject("boSingleton"); DummyBo bop = (DummyBo) bf.GetObject("boPrototype"); Assert.IsFalse(bos == bop); Assert.AreEqual(bos.dao, bop.dao); }
public void PrototypeInheritanceFromParentFactorySingleton() { XmlObjectFactory parent = new XmlObjectFactory(new ReadOnlyXmlTestResource("parent.xml", GetType())); XmlObjectFactory child = new XmlObjectFactory(new ReadOnlyXmlTestResource("child.xml", GetType()), parent); TestObject inherits = (TestObject) child.GetObject("protoypeInheritsFromParentFactorySingleton"); // Name property value is overridden Assert.IsTrue(inherits.Name.Equals("prototypeOverridesInheritedSingleton")); // Age property is inherited from object in parent factory Assert.IsTrue(inherits.Age == 1); TestObject inherits2 = (TestObject) child.GetObject("protoypeInheritsFromParentFactorySingleton"); Assert.AreNotSame(inherits2,inherits); inherits2.Age = 13; Assert.IsTrue(inherits2.Age == 13); // Shouldn't have changed first instance Assert.IsTrue(inherits.Age == 1); }
private void _TypedStringValueIsPickedUp(out Stream stream) { const string xml = @"<?xml version='1.0' encoding='UTF-8' ?> <objects xmlns='http://www.springframework.net' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xsi:schemaLocation='http://www.springframework.net http://www.springframework.net/xsd/spring-objects.xsd'> <object id='golyadkin' type='Spring.Objects.TestObject, Spring.Core.Tests'> <property name='Hats'><value type='string[]'>trilby,fedora</value></property> </object> </objects>"; stream = new MemoryStream(Encoding.UTF8.GetBytes(xml)); XmlObjectFactory fac = new XmlObjectFactory(new InputStreamResource(stream, string.Empty)); IObjectDefinition def = fac.GetObjectDefinition("golyadkin"); PropertyValue value = def.PropertyValues.GetPropertyValue("Hats"); Assert.AreEqual(typeof(TypedStringValue), value.Value.GetType()); TestObject obj = (TestObject) fac.GetObject("golyadkin"); Assert.IsTrue(ArrayUtils.AreEqual(new string[] {"trilby", "fedora"}, obj.Hats)); }
public void SingletonInheritanceFromParentFactorySingletonUsingCtor() { XmlObjectFactory parent = new XmlObjectFactory(new ReadOnlyXmlTestResource("parent.xml", GetType())); XmlObjectFactory child = new XmlObjectFactory(new ReadOnlyXmlTestResource("child.xml", GetType()), parent); TestObject inherits = (TestObject)child.GetObject("inheritsFromParentFactoryUsingCtor"); // Name property value is overriden Assert.IsTrue(inherits.Name.Equals("child-name")); // Age property is inherited from object in parent factory Assert.IsTrue(inherits.Age == 1); TestObject inherits2 = (TestObject)child.GetObject("inheritsFromParentFactoryUsingCtor"); Assert.AreSame(inherits2,inherits); }
public void RefSubelement() { IResource resource = new ReadOnlyXmlTestResource("collections.xml", GetType()); XmlObjectFactory xof = new XmlObjectFactory(resource); //Assert.IsTrue ("5 objects in reftypes, not " + xof.GetObjectDefinitionCount(), xof.GetObjectDefinitionCount() == 5); TestObject jen = (TestObject) xof.GetObject("jenny"); TestObject dave = (TestObject) xof.GetObject("david"); Assert.IsTrue(jen.Spouse == dave); }