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
}
}
public PDFDataBindEventHandler GetDataBindingExpression(string expressionvalue, Type classType, System.Reflection.PropertyInfo forProperty)
{
PDFValueConverter valConv;
if (ParserDefintionFactory.IsSimpleObjectType(forProperty.PropertyType, out valConv))
{
BindingXPathExpression expr = BindingXPathExpression.Create(expressionvalue, valConv, forProperty);
return(new PDFDataBindEventHandler(expr.BindComponent));
}
else if (ParserDefintionFactory.IsCustomParsableObjectType(forProperty.PropertyType, out valConv))
{
BindingXPathExpression expr = BindingXPathExpression.Create(expressionvalue, valConv, forProperty);
return(new PDFDataBindEventHandler(expr.BindComponent));
}
else if (forProperty.PropertyType == typeof(Object))
{
valConv = null;
var expr = BindingXPathExpression.Create(expressionvalue, valConv, forProperty);
return(new PDFDataBindEventHandler(expr.BindComponent));
}
else
{
throw new PDFParserException(string.Format(Errors.ParserAttributeMustBeSimpleOrCustomParsableType, forProperty.Name, forProperty.PropertyType));
}
}
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);
}
public void TestParserControllerDefinition_Loading()
{
//Check the factory loads the controller definition
ParserControllerDefinition defn = ParserDefintionFactory.GetControllerDefinition(TypeName);
Assert.IsNotNull(defn);
Assert.AreEqual(TypeName, defn.ControllerTypeName);
Assert.IsNotNull(defn.ControllerType);
Assert.AreEqual(typeof(TestParsedController), defn.ControllerType);
Assert.IsNotNull(defn.Outlets);
Assert.IsNotNull(defn.Actions);
}
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);
}
public void IsCustomParsableObjectTypeTest()
{
IFormatProvider invariant = System.Globalization.CultureInfo.InvariantCulture;
PDFValueConverter convert;
Type type = typeof(Scryber.Drawing.PDFThickness); //thickness is parsable
string thickvalue = "12 45.3in 12.5 4mm";
bool expected = true;
bool actual = ParserDefintionFactory.IsCustomParsableObjectType(type, out convert);
Assert.AreEqual(expected, actual, "PDFThickness is not registered as parsable");
Assert.IsNotNull(convert);
Scryber.Drawing.PDFThickness thick = (Scryber.Drawing.PDFThickness)convert(thickvalue, type, invariant);
Assert.AreEqual(thick.Top, (Scryber.Drawing.PDFUnit) 12);
Assert.AreEqual(thick.Right, new Scryber.Drawing.PDFUnit(45.3, Scryber.Drawing.PageUnits.Inches));
Assert.AreEqual(thick.Bottom, (Scryber.Drawing.PDFUnit) 12.5);
Assert.AreEqual(thick.Left, new Scryber.Drawing.PDFUnit(4, Scryber.Drawing.PageUnits.Millimeters));
type = typeof(Scryber.Drawing.PDFPen); //pen is not parsable
expected = false;
actual = ParserDefintionFactory.IsCustomParsableObjectType(type, out convert);
Assert.AreEqual(expected, actual);
Assert.IsNull(convert);
}
public void TestParserControllerDefinition_Actions()
{
ParserControllerDefinition defn = ParserDefintionFactory.GetControllerDefinition(TypeName);
Assert.IsNotNull(defn);
ParserControllerAction action;
bool expected = true; //Simple declared method
bool actual = defn.Actions.TryGetAction("SimpleAction", out action);
Assert.AreEqual(expected, actual);
Assert.IsNotNull(action);
Assert.AreEqual("SimpleAction", action.Name);
Assert.IsNotNull(action.ActionMethod);
Assert.AreEqual(MemberTypes.Method, action.ActionMethod.MemberType);
Assert.AreEqual("SimpleAction", action.ActionMethod.Name);
expected = true; //Renamed method - SimpleActionOtherName
actual = defn.Actions.TryGetAction("otheraction", out action);
Assert.AreEqual(expected, actual);
Assert.IsNotNull(action);
Assert.AreEqual("otheraction", action.Name);
Assert.IsNotNull(action.ActionMethod);
Assert.AreEqual(MemberTypes.Method, action.ActionMethod.MemberType);
Assert.AreEqual("SimpleActionOtherName", action.ActionMethod.Name);
expected = false; //Explicit exclusion method - ExcludedAction
actual = defn.Actions.TryGetAction("ExcludedAction", out action);
Assert.AreEqual(expected, actual);
Assert.IsNull(action);
expected = false; //No attribute - NotAnAction
actual = defn.Actions.TryGetAction("NotAnAction", out action);
Assert.AreEqual(expected, actual);
Assert.IsNull(action);
expected = false; //static method - StaticNotAnAction
actual = defn.Actions.TryGetAction("StaticNotAnAction", out action);
Assert.AreEqual(expected, actual);
Assert.IsNull(action);
expected = false; //static method - ProtectedNotAnAction
actual = defn.Actions.TryGetAction("ProtectedNotAnAction", out action);
Assert.AreEqual(expected, actual);
Assert.IsNull(action);
expected = true; //overriden method no attribute on override - OverridenBaseAction
actual = defn.Actions.TryGetAction("OverridenBaseAction", out action);
Assert.AreEqual(expected, actual);
Assert.IsNotNull(action);
Assert.AreEqual("OverridenBaseAction", action.Name);
Assert.IsNotNull(action.ActionMethod);
Assert.AreEqual(MemberTypes.Method, action.ActionMethod.MemberType);
Assert.AreEqual("OverridenBaseAction", action.ActionMethod.Name);
expected = true; //Renamed overriden method - RenamedBaseAction
actual = defn.Actions.TryGetAction("newActionName", out action);
Assert.AreEqual(expected, actual);
Assert.IsNotNull(action);
Assert.AreEqual("newActionName", action.Name);
Assert.IsNotNull(action.ActionMethod);
Assert.AreEqual(MemberTypes.Method, action.ActionMethod.MemberType);
Assert.AreEqual("RenamedBaseAction", action.ActionMethod.Name);
expected = false; //overriden method attribute with IsAction=false - ExcludedBaseAction
actual = defn.Actions.TryGetAction("ExcludedBaseAction", out action);
Assert.AreEqual(expected, actual);
Assert.IsNull(action);
}
public void TestParserControllerDefinition_Outlets()
{
//Check the reported properties and fields on the definition itself
ParserControllerDefinition defn = ParserDefintionFactory.GetControllerDefinition(TypeName);
Assert.IsNotNull(defn);
ParserControllerOutlet outlet;
bool expected = true; //Field
bool actual = defn.Outlets.TryGetOutlet("LabelField", out outlet);
Assert.AreEqual(expected, actual);
Assert.IsNotNull(outlet);
Assert.AreEqual("LabelField", outlet.ID);
Assert.IsNotNull(outlet.OutletMember);
Assert.IsFalse(outlet.Required);
Assert.AreEqual(MemberTypes.Field, outlet.OutletMember.MemberType);
Assert.AreEqual("LabelField", outlet.OutletMember.Name);
expected = true; //Property
actual = defn.Outlets.TryGetOutlet("PlaceholderProperty", out outlet);
Assert.AreEqual(expected, actual);
Assert.IsNotNull(outlet);
Assert.AreEqual("PlaceholderProperty", outlet.ID);
Assert.IsNotNull(outlet.OutletMember);
Assert.IsFalse(outlet.Required);
Assert.AreEqual(MemberTypes.Property, outlet.OutletMember.MemberType);
Assert.AreEqual("PlaceholderProperty", outlet.OutletMember.Name);
expected = false; //should not be there.
actual = defn.Outlets.TryGetOutlet("InvalidStaticField", out outlet);
Assert.AreEqual(expected, actual);
Assert.IsNull(outlet);
expected = false; //should not be there.
actual = defn.Outlets.TryGetOutlet("InvalidStaticProperty", out outlet);
Assert.AreEqual(expected, actual);
Assert.IsNull(outlet);
expected = false; //should not be there.
actual = defn.Outlets.TryGetOutlet("InvalidProtectedField", out outlet);
Assert.AreEqual(expected, actual);
Assert.IsNull(outlet);
expected = false; //should not be there.
actual = defn.Outlets.TryGetOutlet("InvalidProtectedProperty", out outlet);
Assert.AreEqual(expected, actual);
Assert.IsNull(outlet);
expected = true; //Renamed
actual = defn.Outlets.TryGetOutlet("mylabel", out outlet);
Assert.AreEqual(expected, actual);
Assert.IsNotNull(outlet);
Assert.AreEqual("mylabel", outlet.ID);
Assert.IsFalse(outlet.Required);
Assert.IsNotNull(outlet.OutletMember);
Assert.AreEqual(MemberTypes.Property, outlet.OutletMember.MemberType);
Assert.AreEqual("LabelFieldOtherName", outlet.OutletMember.Name);
expected = true; //Renamed and required
actual = defn.Outlets.TryGetOutlet("otherlabel", out outlet);
Assert.AreEqual(expected, actual);
Assert.IsNotNull(outlet);
Assert.AreEqual("otherlabel", outlet.ID);
Assert.IsTrue(outlet.Required);
Assert.IsNotNull(outlet.OutletMember);
Assert.AreEqual(MemberTypes.Property, outlet.OutletMember.MemberType);
Assert.AreEqual("RequiredLabelOtherName", outlet.OutletMember.Name);
expected = false; //Explicit Exclusion
actual = defn.Outlets.TryGetOutlet("ExplicitExcludedLabel", out outlet);
Assert.AreEqual(expected, actual);
Assert.IsNull(outlet);
expected = true; //Property declared on base class
actual = defn.Outlets.TryGetOutlet("BaseClassLabel", out outlet);
Assert.AreEqual(expected, actual);
Assert.IsNotNull(outlet);
Assert.AreEqual("BaseClassLabel", outlet.ID);
Assert.IsNotNull(outlet.OutletMember);
Assert.IsFalse(outlet.Required);
Assert.AreEqual(MemberTypes.Property, outlet.OutletMember.MemberType);
Assert.AreEqual("BaseClassLabel", outlet.OutletMember.Name);
expected = true; //Property declared on base class overriden on sub class - no attribute on override
actual = defn.Outlets.TryGetOutlet("OverridenBaseClassLabel", out outlet);
Assert.AreEqual(expected, actual);
Assert.IsNotNull(outlet);
Assert.AreEqual("OverridenBaseClassLabel", outlet.ID);
Assert.IsNotNull(outlet.OutletMember);
Assert.IsFalse(outlet.Required);
Assert.AreEqual(MemberTypes.Property, outlet.OutletMember.MemberType);
Assert.AreEqual("OverridenBaseClassLabel", outlet.OutletMember.Name);
expected = true; //Property declared on base class, overriden on subclass - renamed
actual = defn.Outlets.TryGetOutlet("renamedbaselabel", out outlet);
Assert.AreEqual(expected, actual);
Assert.IsNotNull(outlet);
Assert.AreEqual("renamedbaselabel", outlet.ID);
Assert.IsNotNull(outlet.OutletMember);
Assert.IsFalse(outlet.Required);
Assert.AreEqual(MemberTypes.Property, outlet.OutletMember.MemberType);
Assert.AreEqual("RenamedBaseClassLabel", outlet.OutletMember.Name);
expected = false; //Property declared on base class overriden on sub class - attribute IsOutlet=false
actual = defn.Outlets.TryGetOutlet("ExcludedInSubClass", out outlet);
Assert.AreEqual(expected, actual);
Assert.IsNull(outlet);
}
public void IsSimpleObjectExplictCultureTest()
{
IFormatProvider french = System.Globalization.CultureInfo.GetCultureInfo("fr-FR");
PDFValueConverter converter;
//Enumueration
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(Scryber.DrawingOrigin), out converter));
Assert.AreEqual(Scryber.DrawingOrigin.BottomLeft, converter.Invoke("BottomLeft", typeof(Scryber.DrawingOrigin), french), "Enum failed");
//Boolean
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(bool), out converter));
Assert.AreEqual(true, converter.Invoke("true", typeof(bool), french), "Boolean failed");
//Byte
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(byte), out converter));
Assert.AreEqual((byte)2, converter.Invoke("2", typeof(byte), french), "Byte failed");
//Char
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(char), out converter));
Assert.AreEqual('c', converter.Invoke("c", typeof(char), french), "Char failed");
//DateTime
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(DateTime), out converter));
Assert.AreEqual(new DateTime(2014, 05, 25, 12, 11, 10), converter.Invoke("25 mai 2014 12:11:10", typeof(DateTime), french), "DateTime failed");
//Decimal
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(decimal), out converter));
Assert.AreEqual(-12.5M, converter.Invoke("-12,5", typeof(decimal), french), "Decimal failed");
//Double
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(double), out converter));
Assert.AreEqual(12.50, converter.Invoke("12,5", typeof(double), french), "Double failed");
//Int16
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(short), out converter));
Assert.AreEqual((short)12, converter.Invoke("12", typeof(short), french), "Short failed");
//Int32
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(int), out converter));
Assert.AreEqual(-12, converter.Invoke("-12", typeof(int), french), "Int32 failed");
//Int64
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(long), out converter));
Assert.AreEqual((long)12, converter.Invoke("12", typeof(long), french), "Long failed");
//SByte
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(SByte), out converter));
Assert.AreEqual((SByte)(-12), converter.Invoke("-12", typeof(sbyte), french), "SByte failed");
//Float
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(float), out converter));
Assert.AreEqual(12.4F, converter.Invoke("12,4", typeof(float), french), "Float failed");
//String
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(string), out converter));
Assert.AreEqual("value", converter.Invoke("value", typeof(string), french), "String failed");
//UInt16
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(ushort), out converter));
Assert.AreEqual((ushort)12, converter.Invoke("12", typeof(ushort), french), "UShort failed");
//Int16
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(uint), out converter));
Assert.AreEqual((uint)12, converter.Invoke("12", typeof(uint), french), "UInt32 failed");
//Int16
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(ulong), out converter));
Assert.AreEqual((ulong)12, converter.Invoke("12", typeof(ulong), french), "UInt64 failed");
//Guid
string guidS = "{62261BCA-DEE5-4285-A406-8236BC8025FA}";
Guid guid = new Guid(guidS);
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(Guid), out converter));
Assert.AreEqual(guid, converter.Invoke(guidS, typeof(Guid), french), "Guid failed");
TimeSpan time = new TimeSpan(234567);
string timeS = time.ToString();
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(TimeSpan), out converter));
Assert.AreEqual(time, converter.Invoke(timeS, typeof(TimeSpan), french), "TimeSpan failed");
string url = "http://www.scryber.co.uk";
Uri uri = new Uri(url);
Assert.IsTrue(ParserDefintionFactory.IsSimpleObjectType(typeof(Uri), out converter));
Assert.AreEqual(uri, converter.Invoke(url, typeof(Uri), french), "URI failed");
Fakes.ParserRootOne complex = new Fakes.ParserRootOne();
Assert.IsFalse(ParserDefintionFactory.IsSimpleObjectType(complex.GetType(), out converter));
Assert.IsNull(converter);
}
