public void InvalidAttributeTests()
{
bool isremote = false;
try
{
ParserClassDefinition defn = ParserDefintionFactory.GetClassDefinition("Invalid-Inherits", NamespaceAssembly, true, out isremote);
Assert.IsNotNull(defn);
throw new InvalidOperationException("No Exception raised for the 'inherits' attribute");
}
catch (PDFParserException)
{
//Successfully caught the parser exception for invalid attribute name
}
try
{
ParserClassDefinition defn = ParserDefintionFactory.GetClassDefinition("Invalid-Code", NamespaceAssembly, true, out isremote);
Assert.IsNotNull(defn);
throw new InvalidOperationException("No Exception raised for the 'inherits' attribute");
}
catch (PDFParserException)
{
//Successfully caught the parser exception for invalid attribute name
}
}
/// <summary>
/// Validates the attributes on the Fakes.ParserInnerComplex type
/// </summary>
/// <param name="defn"></param>
private void ValidateInnerDefn(ParserClassDefinition defn)
{
Assert.AreEqual(5, defn.Attributes.Count);
Assert.AreEqual(0, defn.Elements.Count);
Assert.IsNull(defn.DefaultElement);
Assert.IsTrue(defn.IsMaxFrameworkSupported); //not defined
Assert.IsTrue(defn.IsMinFrameworkSupported); //not defined
ParserAttributeDefinition attr;
ParserPropertyDefinition prop;
Assert.IsTrue(defn.Attributes.TryGetPropertyDefinition("index", string.Empty, out prop)); //defined on base class
Assert.AreEqual("Index", prop.PropertyInfo.Name);
attr = prop as ParserAttributeDefinition;
Assert.IsNotNull(attr);
Assert.IsFalse(defn.Attributes.TryGetPropertyDefinition("another-name", string.Empty, out prop));
Assert.IsFalse(defn.Attributes.TryGetPropertyDefinition("AnotherIndex", string.Empty, out prop)); //Does not exist
Assert.IsFalse(defn.Attributes.TryGetPropertyDefinition("inherits", string.Empty, out prop)); //defined but overridden
Assert.IsTrue(defn.Attributes.TryGetPropertyDefinition("concrete", NamespaceAssembly, out prop)); //the override
Assert.IsTrue(defn.Attributes.TryGetPropertyDefinition("size", null, out prop));
Assert.IsTrue(defn.Attributes.TryGetPropertyDefinition("ro-size", null, out prop));
Assert.IsTrue(defn.Attributes.TryGetPropertyDefinition("date", null, out prop));
//TODO: Events
}
public void GetClassDefinitionTest()
{
ParserClassDefinition defn = ParserDefintionFactory.GetClassDefinition(typeof(Fakes.ParserRootOne));
Assert.IsNotNull(defn);
this.ValidateRootOneDefn(defn);
defn = ParserDefintionFactory.GetClassDefinition(typeof(Fakes.ParserInnerComplex));
this.ValidateInnerDefn(defn);
}
/// <summary>
/// Validates that the expected class definition matches the loaded definition for the Fakes.ParserRootOne class
/// </summary>
/// <param name="defn"></param>
private void ValidateRootOneDefn(ParserClassDefinition defn)
{
Assert.AreEqual(defn.ClassType, typeof(Fakes.ParserRootOne));
//Check the required versions
Assert.AreEqual(new Version(0, 8, 0, 0), defn.MinRequiredFramework);
Assert.IsTrue(defn.IsMinFrameworkSupported);
//name attribute
Assert.AreEqual(1, defn.Attributes.Count);
ParserAttributeDefinition name = defn.Attributes[0] as ParserAttributeDefinition;
Assert.IsNotNull(name, "No item was returned by index or it is not an Attribute definition");
Assert.AreEqual("name", name.Name, "Name of the attribute definition and the name in the colection do not match");
Assert.IsNotNull(name.Converter, "No converter for the string attribute 'name'");
Assert.IsFalse(name.IsCodeDomGenerator);
Assert.AreEqual(2, defn.Elements.Count);
//First element - complex
ParserComplexElementDefiniton complex = defn.Elements["Complex-Element"] as ParserComplexElementDefiniton;
Assert.IsNotNull(complex);
Assert.AreEqual("Complex-Element", complex.Name);
Assert.AreEqual(String.Empty, complex.NameSpace);
Assert.AreEqual(DeclaredParseType.ComplexElement, complex.ParseType);
Assert.IsNotNull(complex.PropertyInfo);
Assert.AreEqual("Complex", complex.PropertyInfo.Name);
Assert.AreEqual(typeof(Fakes.ParserInnerComplex), complex.ValueType);
//Second element - collection of ParserInnerComplex with explicit namespace
ParserArrayDefinition collection = defn.Elements["Collection-One", NamespaceAssembly] as ParserArrayDefinition;
Assert.IsNotNull(collection);
Assert.AreEqual("Collection-One", collection.Name);
Assert.IsFalse(collection.IsCustomParsable);
//Assert.AreEqual(NamespaceAssembly, collection.NameSpace);
Assert.AreEqual(DeclaredParseType.ArrayElement, collection.ParseType);
Assert.AreEqual("CollectionOne", collection.PropertyInfo.Name);
Assert.AreEqual(typeof(Fakes.ParserCollection), collection.ValueType);
Assert.AreEqual(typeof(Fakes.ParserInnerComplex), collection.ContentType);
//Third element - default collection of ParserInnerBase
collection = defn.DefaultElement as ParserArrayDefinition;
Assert.IsNotNull(collection);
Assert.AreEqual("", collection.Name);
Assert.IsFalse(collection.IsCustomParsable);
Assert.AreEqual(string.Empty, collection.NameSpace);
Assert.AreEqual(DeclaredParseType.ArrayElement, collection.ParseType);
Assert.AreEqual("DefaultCollection", collection.PropertyInfo.Name);
Assert.AreEqual(typeof(Fakes.ParserCollection), collection.ValueType);
Assert.AreEqual(typeof(Fakes.ParserInnerBase), collection.ContentType);
}
public void GetClassDefinitionTest1()
{
bool isremote = false;
ParserClassDefinition defn = ParserDefintionFactory.GetClassDefinition("Root1", NamespaceAssembly, true, out isremote);
Assert.IsNotNull(defn);
ValidateRootOneDefn(defn);
defn = ParserDefintionFactory.GetClassDefinition("Inner", NamespaceAssembly, true, out isremote);
Assert.IsNotNull(defn);
ValidateInnerDefn(defn);
defn = ParserDefintionFactory.GetClassDefinition("Inner-Ref", NamespaceAssembly, true, out isremote);
Assert.IsNotNull(defn);
Assert.IsTrue(isremote);
ValidateInnerDefn(defn);
}
