public void NonMathcingPropertyTest()
{
var context = new RIContext();
var nameInstanceProvider = new SimpleInstanceProvider("Jørgen");
var ageInstanceProvider = new SimpleInstanceProvider(49);
var genderInstanceProvider = new EnumInstanceProvider(Gender.Male, typeof(Gender));
try
{
var classInstanceProvider = new ComplexInstanceProvider(
typeof(Person),
new IInstanceProvider[] {
nameInstanceProvider,
ageInstanceProvider,
genderInstanceProvider
},
new Dictionary <string, IInstanceProvider>()
{
{ "Shoe Size", new SimpleInstanceProvider(44) },
}
);
Assert.Fail("A NoMatchingPropertyException was expected.");
}
catch (NoMatchingPropertyException)
{
}
catch (Exception)
{
Assert.Fail("Another exception than NoMatchingPropertyException was not expected.");
}
}
public void TestTwoParams()
{
var context = new RIContext();
context.AddNamedInstanceProvider("A", new ComplexInstanceProvider(
typeof(TestClass),
new IInstanceProvider[] {
new SimpleInstanceProvider(36),
new ListInstanceProvider(
new IInstanceProvider[]
{
new SimpleInstanceProvider("Text1"),
new SimpleInstanceProvider("Text2"),
},
ListInstanceProvider.CollectionType.Array
),
},
new Dictionary <string, IInstanceProvider>()
{
}
)
);
var instance = context.GetInstance <TestClass>("A");
var text = instance.GetText();
Assert.AreEqual("36 Text1, Text2", text);
}
private static void ParseNameMappings(XElement xNameMappings, RIContext context)
{
foreach (var xNameMapping in xNameMappings.Elements())
{
ParseNameMapping(xNameMapping, context);
}
}
private static IInstanceProvider ParseInstanceElement(XElement xInstance, RIContext context)
{
var tagName = xInstance.Name.LocalName;
switch (tagName)
{
case "simple-instance":
return(ParseSimpleInstanceElement(xInstance));
case "complex-instance":
return(ParseComplexInstanceElement(xInstance, context));
case "static-instance":
return(ParseStaticInstanceElement(xInstance, context));
case "reference":
return(ParseReferenceInstanceElement(xInstance, context));
case "list":
return(ParseListInstanceElement(xInstance, context));
case "null-instance":
return(ParseNullInstanceElement(xInstance, context));
default:
throw new UnexpectedXmlElementException(xInstance, "A 'simple-instance' or a 'complex-instance' element was expected.");
}
}
public void ClassTypeTest()
{
var context = new RIContext();
var nameInstanceProvider = new SimpleInstanceProvider("Jørgen");
var ageInstanceProvider = new SimpleInstanceProvider(49);
var genderInstanceProvider = new EnumInstanceProvider(Gender.Male, typeof(Gender));
var dateOfBirth = new DateTime(1966, 7, 14);
var classInstanceProvider = new ComplexInstanceProvider(
typeof(Person),
new IInstanceProvider[] {
nameInstanceProvider,
ageInstanceProvider,
genderInstanceProvider
},
new Dictionary <string, IInstanceProvider>()
{
{ "Birthday", new SimpleInstanceProvider(dateOfBirth) },
}
);
context.AddNamedInstanceProvider("A", classInstanceProvider);
var person = context.GetInstance <Person>("A");
Assert.AreEqual("Jørgen", person.Name);
var now = DateTime.Today;
var age = now.Year - dateOfBirth.Year + (now.DayOfYear >= dateOfBirth.DayOfYear ? 0 : -1);
Assert.AreEqual(age, person.Age);
Assert.AreEqual(Gender.Male, person.Gender);
}
private static void ParseIncludes(XContainer xIncludes, RIContext context)
{
foreach (var xChild in xIncludes.Elements())
{
context.IncludeAssembly(xChild.Value);
}
}
public void NonMathcingFieldTest()
{
var context = new RIContext();
try
{
var classInstanceProvider = new ComplexInstanceProvider(
typeof(Address),
new IInstanceProvider[]
{
},
new Dictionary <string, IInstanceProvider>()
{
{ "AddressLine1", new SimpleInstanceProvider("Vesterbygdvej 10") },
{ "ZipCode", new SimpleInstanceProvider("3650") }
}
);
Assert.Fail("A NoMatchingPropertyException was expected.");
}
catch (NoMatchingPropertyException)
{
}
catch (Exception)
{
Assert.Fail("Another exception than NoMatchingPropertyException was not expected.");
}
}
public void NonMathcingContructorClassTypeTest()
{
var context = new RIContext();
var genderInstanceProvider = new EnumInstanceProvider(Gender.Male, typeof(Gender));
var nameInstanceProvider = new SimpleInstanceProvider("Jørgen");
try
{
var classInstanceProvider = new ComplexInstanceProvider(
typeof(Person),
new IInstanceProvider[] {
genderInstanceProvider,
nameInstanceProvider,
},
new Dictionary <string, IInstanceProvider>()
{
{ "Birthday", new SimpleInstanceProvider(new DateTime(1966, 7, 14)) },
}
);
Assert.Fail("A NoMatchingConstructorException was expected.");
}
catch (NoMatchingConstructorException)
{
}
catch (Exception)
{
Assert.Fail("Another exception than NoMatchingConstructorException was not expected.");
}
}
private static void ParseNamedInstances(XContainer xNamedInstances, RIContext context)
{
foreach (var xChild in xNamedInstances.Elements())
{
var instanceProvider = ParseInstanceElement(xChild, context);
var name = xChild.Attribute("name").Value;
context.AddNamedInstanceProvider(name, instanceProvider);
}
}
public void ConstantStringTest()
{
var context = new RIContext();
context.AddNamedInstanceProvider("A", new StaticInstanceProvider(typeof(Runerne.Instantiation.UnitTest.StaticClass), "Constant"));
var s = context.GetInstance <string>("A");
Assert.IsInstanceOfType(s, typeof(string));
Assert.AreEqual("The content of the constant.", s);
}
public void NullInstanceTypeStrongTest()
{
var context = new RIContext();
context.AddNamedInstanceProvider("A", new NullTypeInstanceProvider(typeof(string)));
var s = context.GetInstance <string>("A");
Assert.IsNull(s);
}
public void StringTypeTest()
{
var context = new RIContext();
context.AddNamedInstanceProvider("A", new SimpleInstanceProvider("This is a test!"));
var s = context.GetInstance <string>("A");
Assert.AreEqual("This is a test!", s);
}
public void BooleanTypeTest()
{
var context = new RIContext();
context.AddNamedInstanceProvider("0", new SimpleInstanceProvider(false));
context.AddNamedInstanceProvider("1", new SimpleInstanceProvider(true));
var falseValue = context.GetInstance <bool>("0");
Assert.IsFalse(falseValue);
var trueValue = context.GetInstance <bool>("1");
Assert.IsTrue(trueValue);
}
public void NoSuchInstanceProviderTest()
{
var context = new RIContext();
context.AddNamedInstanceProvider("TheName", null);
try
{
context.GetInstanceProvider("Kurt");
Assert.Fail("A NoSuchInstanceProviderException was expected thrown.");
}
catch (NoSuchInstanceProviderException ex)
{
Assert.AreEqual("Kurt", ex.Name);
}
}
public void DuplicatedNameTest()
{
var context = new RIContext();
context.AddNamedInstanceProvider("TheName", null);
try
{
context.AddNamedInstanceProvider("TheName", null);
Assert.Fail("A DuplicateInstanceNameException was expected thrown.");
}
catch (DuplicateInstanceNameException ex)
{
Assert.AreEqual("TheName", ex.Name);
}
}
public void MathcingFieldTest()
{
var context = new RIContext();
var classInstanceProvider = new ComplexInstanceProvider(
typeof(Address),
new IInstanceProvider[]
{
},
new Dictionary <string, IInstanceProvider>()
{
{ "AddressLine1", new SimpleInstanceProvider("Vesterbygdvej 10") },
{ "City", new SimpleInstanceProvider("Ølstykke") }
}
);
}
private static void ParseNameMapping(XElement xNameMapping, RIContext context)
{
RIName to = xNameMapping.Attribute("to").Value;
var instanceProvider = context.GetInstanceProvider(to);
var fromAttribute = xNameMapping.Attribute("from");
if (fromAttribute != null)
{
context.AddNamedInstanceProvider(fromAttribute.Value, instanceProvider);
}
foreach (var xFrom in xNameMapping.Elements(Ns + "from"))
{
RIName from = xFrom.Value;
context.AddNamedInstanceProvider(from, instanceProvider);
}
}
public void NoNullInstanceTypeStrongTest()
{
var context = new RIContext();
context.AddNamedInstanceProvider("A", new NullTypeInstanceProvider(typeof(string)));
try
{
var s = context.GetInstance <int>("A");
Assert.Fail("An IncompatibleInstanceTypeException was expected.");
}
catch (IncompatibleInstanceTypeException)
{
}
catch (Exception)
{
Assert.Fail("Another exception than IncompatibleInstanceTypeException was not expected.");
}
}
/// <summary>
/// Loads a context by interpreting the specified root element. The specified arguments will be properties in the context.
/// </summary>
/// <param name="xRoot">The root element that will be interpreted along with all the child elements.</param>
/// <param name="arguments">Initial properties.</param>
/// <returns>The loaded context.</returns>
public static RIContext Parse(XElement xRoot, IDictionary <string, object> arguments = null)
{
if (arguments == null)
{
arguments = new Dictionary <string, object> {
}
}
;
var context = new RIContext();
foreach (var key in arguments.Keys)
{
context.AddNamedInstanceProvider(key, new SimpleInstanceProvider(arguments[key]));
}
ParseRootElement(xRoot, context);
return(context);
}
private static IInstanceProvider ParseListInstanceElement(XElement xList, RIContext context)
{
var collector = new List <IInstanceProvider>();
foreach (var xChild in xList.Elements())
{
var instanceProvider = ParseInstanceElement(xChild, context);
collector.Add(instanceProvider);
}
var collectionType = GetCollectionType(xList);
var elementTypeAttribute = xList.Attribute("element-type");
if (elementTypeAttribute == null)
{
return(new ListInstanceProvider(collector, collectionType));
}
var elementType = context.GetType(elementTypeAttribute.Value);
return(new ListInstanceProvider(collector, elementType, collectionType));
}
public void ElementTypeDerivingListTest()
{
var context = new RIContext();
var instanceProvider = new ListInstanceProvider(
new IInstanceProvider[] {
new SimpleInstanceProvider("Test"),
new SimpleInstanceProvider("Horse"),
new SimpleInstanceProvider("Cat"),
}
);
context.AddNamedInstanceProvider("A", instanceProvider);
var s = context.GetInstance <IEnumerable <string> >("A");
var a = s.ToArray();
Assert.AreEqual(3, a.Length);
Assert.AreEqual("Test", a[0]);
Assert.AreEqual("Horse", a[1]);
Assert.AreEqual("Cat", a[2]);
}
private static void ParseRootElement(XElement xRoot, RIContext context)
{
if (xRoot.Name != Ns + "context")
{
throw new UnexpectedXmlElementException(xRoot, $"A '{{{Ns}}}:context' element was expected.");
}
foreach (var xIncludes in xRoot.Elements(Ns + "includes"))
{
ParseIncludes(xIncludes, context);
}
foreach (var xInstances in xRoot.Elements(Ns + "instances"))
{
ParseNamedInstances(xInstances, context);
}
foreach (var xNameMappings in xRoot.Elements(Ns + "name-mappings"))
{
ParseNameMappings(xNameMappings, context);
}
}
private static ComplexInstanceProvider ParseComplexInstanceElement(XElement xComplexInstance, RIContext context)
{
var typeName = xComplexInstance.Attribute("class").Value;
try
{
var type = context.GetType(typeName);
var constructorInstanceProviders = new List <IInstanceProvider>();
foreach (var xConstructorArg in xComplexInstance.Elements(Ns + "constructor-args").Elements())
{
constructorInstanceProviders.Add(ParseInstanceElement(xConstructorArg, context));
}
var propertiesInstanceProviders = new Dictionary <string, IInstanceProvider>();
foreach (var xProperty in xComplexInstance.Elements(Ns + "properties").Elements())
{
var name = xProperty.Attribute("name").Value;
if (propertiesInstanceProviders.ContainsKey(name))
{
throw new XmlException(xProperty, $"A value for the property by the name '{name}' has already been defined.");
}
propertiesInstanceProviders[name] = ParseInstanceElement(xProperty, context);
}
return(new ComplexInstanceProvider(type, constructorInstanceProviders, propertiesInstanceProviders));
}
catch (XmlException)
{
throw;
}
catch (Exception ex)
{
throw new XmlException(xComplexInstance, ex);
}
}
private static IInstanceProvider ParseStaticInstanceElement(XElement xStaticInstance, RIContext context)
{
var typeName = xStaticInstance.Attribute("type").Value;
try
{
var type = context.GetType(typeName);
var memberName = xStaticInstance.Attribute("member").Value;
return(new StaticInstanceProvider(type, memberName));
}
catch (XmlException)
{
throw;
}
catch (Exception ex)
{
throw new XmlException(xStaticInstance, ex);
}
}
private static IInstanceProvider ParseReferenceInstanceElement(XElement xReference, RIContext context)
{
var refAttribute = xReference.Attribute("ref");
var referencedName = refAttribute.Value;
var instanceProvider = new ReferenceProvider(referencedName, context);
return(instanceProvider);
}
private static IInstanceProvider ParseNullInstanceElement(XElement xNullInstance, RIContext context)
{
var typeName = xNullInstance.Attribute("type")?.Value;
if (typeName == null)
{
try
{
return(new NullTypeInstanceProvider(typeof(object)));
}
catch (Exception ex)
{
throw new XmlException(xNullInstance, ex);
}
}
else
{
var type = context.GetType(typeName);
return(new NullTypeInstanceProvider(type));
}
}