public void ShouldFindErrorMessage2()
{
var engine = new Engine();
engine.For <CompositeClass>()
.Setup(c => c.Value)
.MustBeGreaterThan(0)
.Setup(c => c.C)
.MustNotBeNull()
.Setup(c => c.C.C)
.WithMessage("Composed value is not valid")
.MustBeBetween(1, 10, Rules.BetweenRuleBoundsOption.BothInclusive)
;
var o = new CompositeClass()
{
C = new ClassC()
};
var r = new ValidationReport(engine);
r.Validate(o);
Assert.AreEqual("Composed value is not valid", r.GetErrorMessage(o, f => f.C.C));
//NOTE: There are no errors on ClassC! Should return null.
Assert.IsNull(r.GetErrorMessage(o.C, f => f.C));
}
/// <summary>
/// Assembles the code using the source file
/// </summary>
/// <returns></returns>
public string GetCode()
{
CompositeClass compositeClass = ReadSourceFile();
CodeCompileUnit unit = CreateCodeCompileUnit(compositeClass);
return(CovertCodeCompileUnit(unit));
}
public void ShouldFindErrorMessage()
{
var builder = new Fluent.FluentBuilder();
builder.For <ClassC>()
.Setup(c => c.C)
.WithMessage("C is not valid")
.MustBeBetween(1, 10, Rules.BetweenRuleBoundsOption.BothInclusive);
builder.For <CompositeClass>()
.Setup(c => c.Value)
.MustBeGreaterThan(0)
.Setup(c => c.C)
.CallValidate()
.WithMessage("Composed value is not valid");
var engine = builder.Build();
var o = new CompositeClass()
{
C = new ClassC()
};
var r = new ValidationReport(engine);
r.Validate(o);
Assert.AreEqual("Composed value is not valid", r.GetErrorMessage(o, f => f.C));
Assert.AreEqual("C is not valid", r.GetErrorMessage(o.C, f => f.C));
}
public void Main()
{
// Create a tree structure
var root = new CompositeClass();
root.Add(new Leaf());
root.Add(new Leaf());
root.Add(new Leaf());
// Create a branch
var compositeElement = new CompositeClass();
compositeElement.Add(new Leaf());
compositeElement.Add(new Leaf());
root.Add(compositeElement);
// Add and remove a PrimitiveElement
var primitive = new Leaf();
root.Add(primitive);
root.Remove(primitive);
//Say we have a collection of these
var components = new List <IComponent> {
root, compositeElement, primitive
};
//We lost some uniformity, so we have to type check
foreach (var component in components)
{
if (component is IComposite)
{
(component as IComposite).Add(new Leaf());
}
}
root.Write();
}
public void ShouldFindErrorMessage3()
{
var engine = new Engine();
engine.For <ClassC>().WithMessage("ClassC is not valid")
.Setup(c => c.C)
.MustBeBetween(1, 10);
engine.For <CompositeClass>()
.Setup(c => c.C)
.CallValidate();
var o = new CompositeClass()
{
C = new ClassC()
};
var r = new ValidationReport(engine);
r.Validate(o);
Assert.AreEqual("ClassC is not valid", r.GetErrorMessage(o, f => f.C));
}
public void ShouldFindErrorMessage2()
{
var builder = new Fluent.FluentBuilder();
builder.For<CompositeClass>()
.Setup(c => c.Value)
.MustBeGreaterThan(0)
.Setup(c => c.C)
.MustNotBeNull()
.Setup(c => c.C.C)
.WithMessage("Composed value is not valid")
.MustBeBetween(1, 10, Rules.BetweenRuleBoundsOption.BothInclusive)
;
var engine = builder.Build();
var o = new CompositeClass() { C = new ClassC() };
var r = new ValidationReport(engine);
r.Validate(o);
Assert.AreEqual("Composed value is not valid", r.GetErrorMessage(o.C, f => f.C));
//NOTE: There are no errors on ClassC! Should return null.
Assert.IsNull(r.GetErrorMessage(o, f => f.C.C));
}
public CodeCompileUnit CreateCodeCompileUnit(CompositeClass compositeClass)
{
CodeCompileUnit unit = new CodeCompileUnit();
CodeNamespace ns = new CodeNamespace(GetNamespace(compositeClass.RootNamespace));
foreach (string newNamespace in compositeClass.Namespaces)
{
CodeNamespaceImport import = new CodeNamespaceImport(newNamespace);
ns.Imports.Add(import);
}
unit.Namespaces.Add(ns);
CodeTypeDeclaration generatedClass = new CodeTypeDeclaration(GetClassName());
generatedClass.IsClass = true;
generatedClass.IsPartial = true;
generatedClass.TypeAttributes = TypeAttributes.Public;
ns.Types.Add(generatedClass);
// add private fields
foreach (CompositeType compositeType in compositeClass.Types)
{
CodeMemberField privateVariable = new CodeMemberField(compositeType.ClassName, compositeType.GetFieldName());
privateVariable.Attributes = MemberAttributes.Private;
generatedClass.Members.Add(privateVariable);
}
// add constructor
CodeConstructor ctor = new CodeConstructor();
ctor.Attributes = MemberAttributes.Public;
// add the parameters and field assignments
foreach (CompositeType compositeType in compositeClass.Types)
{
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(
compositeType.ClassName, compositeType.GetParameterName());
ctor.Parameters.Add(param);
// add field assignment
CodeFieldReferenceExpression leftRef;
leftRef = new CodeFieldReferenceExpression();
//leftRef.TargetObject = new CodeThisReferenceExpression();
leftRef.FieldName = compositeType.GetFieldName();
CodeFieldReferenceExpression rightRef;
rightRef = new CodeFieldReferenceExpression();
//rightRef.TargetObject = new CodeThisReferenceExpression();
rightRef.FieldName = compositeType.GetParameterName();
CodeAssignStatement assign = new CodeAssignStatement();
assign.Left = leftRef;
assign.Right = rightRef;
ctor.Statements.Add(assign);
}
generatedClass.Members.Add(ctor);
// add properties
foreach (CompositeType compositeType in compositeClass.Types)
{
foreach (CompositeProperty property in compositeType.Properties)
{
AttachProperty(generatedClass, compositeType, property);
}
}
return(unit);
}
private CompositeClass ReadSourceFile()
{
Assembly[] assemblies = _customTool.GetReferencedAssemblies(false);
CompositeClass compositeClass = new CompositeClass(assemblies);
compositeClass.Namespaces.Add("System");
XmlDocument document = new XmlDocument();
document.Load(_inputFileName);
XmlNode compositeNode = document.SelectSingleNode(CompositeXPath);
compositeClass.RootNamespace = GetNodeValue(compositeNode, "@rootNamespace");
XmlNodeList types = document.SelectNodes(TypesXPath);
foreach (XmlNode typeNode in types)
{
string name = GetNodeValue(typeNode, "@name");
string className = GetNodeValue(typeNode, "@className");
string theNamespace = GetNodeValue(typeNode, "@namespace");
if (!compositeClass.Namespaces.Contains(theNamespace))
{
compositeClass.Namespaces.Add(theNamespace);
}
CompositeType compositeType = new CompositeType(name, className, theNamespace);
compositeClass.Types.Add(compositeType);
Type actualType = FindType(className, theNamespace);
foreach (PropertyInfo pi in actualType.GetProperties())
{
if (pi.CanRead && pi.CanWrite)
{
CompositeProperty property = new CompositeProperty(compositeType.TypeName, pi.Name, pi.PropertyType);
compositeType.Properties.Add(property);
}
}
XmlNodeList hiddenNodes = typeNode.SelectNodes(PropertiesXPath);
foreach (XmlNode propertyNode in hiddenNodes)
{
string propertyName = GetNodeValue(propertyNode, "@name");
string alias = GetNodeValue(propertyNode, "@alias");
bool isReadOnly = GetBooleanNodeValue(propertyNode, "@isReadOnly");
bool isHidden = GetBooleanNodeValue(propertyNode, "@isHidden");
CompositeProperty property = compositeType.Properties.FindCompositeProperty(name, propertyName);
if (property != null)
{
if (!String.IsNullOrEmpty(alias))
{
property.Alias = alias;
}
property.IsReadOnly = isReadOnly;
property.IsHidden = isHidden;
}
}
}
return(compositeClass);
}
public void LoadFile(string filename)
{
_compositeClass = new CompositeClass();
_compositeClass.LoadFile(filename);
}
public void ShouldFindErrorMessage3()
{
var builder = new Fluent.FluentBuilder();
builder.For<ClassC>().WithMessage("ClassC is not valid")
.Setup(c => c.C)
.MustBeBetween(1, 10);
builder.For<CompositeClass>()
.Setup(c => c.C)
.CallValidate();
var engine = builder.Build();
var o = new CompositeClass() { C = new ClassC() };
var r = new ValidationReport(engine);
r.Validate(o);
Assert.AreEqual("ClassC is not valid", r.GetErrorMessage(o, f => f.C));
}
public void ShouldFindErrorMessage4()
{
var builder = new Fluent.FluentBuilder();
builder.For<ClassC>()
.Setup(c => c.C)
.WithMessage("C is not valid")
.MustBeBetween(1, 10, Rules.BetweenRuleBoundsOption.BothInclusive);
builder.For<CompositeClass>()
.Setup(c => c.Value)
.MustBeGreaterThan(0)
.Setup(c => c.C)
.MustNotBeNull()
.WithMessage("C Must not be null")
.CallValidate()
.WithMessage("Composed value is not valid");
var engine = builder.Build();
var o = new CompositeClass() { C = new ClassC() };
var r = new ValidationReport(engine);
r.Validate(o);
Assert.AreEqual("Composed value is not valid", r.GetErrorMessage(o, f => f.C));
Assert.AreEqual("C is not valid", r.GetErrorMessage(o.C, f => f.C));
var o1 = new CompositeClass() { C = null };
var r1 = new ValidationReport(engine);
r1.Validate(o1);
Assert.AreEqual("C Must not be null", r1.GetErrorMessage(o1, f => f.C));
}
public CodeCompileUnit CreateCodeCompileUnit(CompositeClass compositeClass)
{
CodeCompileUnit unit = new CodeCompileUnit();
CodeNamespace ns = new CodeNamespace(GetNamespace(compositeClass.RootNamespace));
foreach (string newNamespace in compositeClass.Namespaces)
{
CodeNamespaceImport import = new CodeNamespaceImport(newNamespace);
ns.Imports.Add(import);
}
unit.Namespaces.Add(ns);
CodeTypeDeclaration generatedClass = new CodeTypeDeclaration(GetClassName());
generatedClass.IsClass = true;
generatedClass.IsPartial = true;
generatedClass.TypeAttributes = TypeAttributes.Public;
ns.Types.Add(generatedClass);
// add private fields
foreach (CompositeType compositeType in compositeClass.Types)
{
CodeMemberField privateVariable = new CodeMemberField(compositeType.ClassName, compositeType.GetFieldName());
privateVariable.Attributes = MemberAttributes.Private;
generatedClass.Members.Add(privateVariable);
}
// add constructor
CodeConstructor ctor = new CodeConstructor();
ctor.Attributes = MemberAttributes.Public;
// add the parameters and field assignments
foreach (CompositeType compositeType in compositeClass.Types)
{
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(
compositeType.ClassName, compositeType.GetParameterName());
ctor.Parameters.Add(param);
// add field assignment
CodeFieldReferenceExpression leftRef;
leftRef = new CodeFieldReferenceExpression();
//leftRef.TargetObject = new CodeThisReferenceExpression();
leftRef.FieldName = compositeType.GetFieldName();
CodeFieldReferenceExpression rightRef;
rightRef = new CodeFieldReferenceExpression();
//rightRef.TargetObject = new CodeThisReferenceExpression();
rightRef.FieldName = compositeType.GetParameterName();
CodeAssignStatement assign = new CodeAssignStatement();
assign.Left = leftRef;
assign.Right = rightRef;
ctor.Statements.Add(assign);
}
generatedClass.Members.Add(ctor);
// add properties
foreach (CompositeType compositeType in compositeClass.Types)
{
foreach (CompositeProperty property in compositeType.Properties)
{
AttachProperty(generatedClass, compositeType, property);
}
}
return unit;
}
private CompositeClass ReadSourceFile()
{
Assembly[] assemblies = _customTool.GetReferencedAssemblies(false);
CompositeClass compositeClass = new CompositeClass(assemblies);
compositeClass.Namespaces.Add("System");
XmlDocument document = new XmlDocument();
document.Load(_inputFileName);
XmlNode compositeNode = document.SelectSingleNode(CompositeXPath);
compositeClass.RootNamespace = GetNodeValue(compositeNode, "@rootNamespace");
XmlNodeList types = document.SelectNodes(TypesXPath);
foreach (XmlNode typeNode in types)
{
string name = GetNodeValue(typeNode, "@name");
string className = GetNodeValue(typeNode, "@className");
string theNamespace = GetNodeValue(typeNode, "@namespace");
if (!compositeClass.Namespaces.Contains(theNamespace))
{
compositeClass.Namespaces.Add(theNamespace);
}
CompositeType compositeType = new CompositeType(name, className, theNamespace);
compositeClass.Types.Add(compositeType);
Type actualType = FindType(className, theNamespace);
foreach (PropertyInfo pi in actualType.GetProperties())
{
if (pi.CanRead && pi.CanWrite)
{
CompositeProperty property = new CompositeProperty(compositeType.TypeName, pi.Name, pi.PropertyType);
compositeType.Properties.Add(property);
}
}
XmlNodeList hiddenNodes = typeNode.SelectNodes(PropertiesXPath);
foreach (XmlNode propertyNode in hiddenNodes)
{
string propertyName = GetNodeValue(propertyNode, "@name");
string alias = GetNodeValue(propertyNode, "@alias");
bool isReadOnly = GetBooleanNodeValue(propertyNode, "@isReadOnly");
bool isHidden = GetBooleanNodeValue(propertyNode, "@isHidden");
CompositeProperty property = compositeType.Properties.FindCompositeProperty(name, propertyName);
if (property != null)
{
if (!String.IsNullOrEmpty(alias))
{
property.Alias = alias;
}
property.IsReadOnly = isReadOnly;
property.IsHidden = isHidden;
}
}
}
return compositeClass;
}
