public void CheckWrongNamespaceTest()
{
var root = new RootObjectNode("Window");
var st = new SyntaxTree(new List<string> { "System.Windows.Forms" }, root, new List<ObjectNode> { root });
analyzer.Analyze(st);
}
public void CheckTypeTest()
{
var st = new SyntaxTree(null,
new List<ObjectNode>
{
new RootObjectNode("ArrayList")
});
analyzer.Analyze(st);
}
public string Build(SyntaxTree tree, string @class, string @namespace)
{
var result = string.Empty;
if (tree.Namespaces != null)
result = CreateNamespaces(tree.Namespaces) + nl;
result += CreateRootObject(tree, @class, @namespace);
return result;
}
public void Analyze(SyntaxTree tree)
{
if (tree.Namespaces != null)
{
CheckNamespaces(tree.Namespaces.Concat(namespaces).Distinct());
}
else
{
tree.Namespaces = namespaces;
CheckNamespaces(tree.Namespaces);
}
CheckObjects(tree);
tree.Objects = tree.Objects.TSort(obj => GetDependencies(tree.Objects, obj.ConstructorArguments));
}
public void SamePropsTest()
{
var st = new SyntaxTree(null,
new List<ObjectNode>()
{
new RootObjectNode("Window", null, new List<PropertyNode>() { new PropertyNode("Width", new NumberNode(1)), new PropertyNode("Width", new NumberNode(1)) })
});
analyzer.Analyze(st);
}
public void ZeroObjectsTest()
{
var st = new SyntaxTree(null, new List<ObjectNode>());
analyzer.Analyze(st);
}
public void PropRefTypeTest()
{
var st = new SyntaxTree(null,
new List<ObjectNode>()
{
new ObjectNode("Uri", "uri", new List<IValueNode>() { new StringNode("ico.ico") }),
new RootObjectNode("Window", null, new List<PropertyNode>() { new PropertyNode("Content", new ReferenceNode("uri", "Uri")) })
});
analyzer.Analyze(st);
}
public void PropStrTypeTest()
{
var st = new SyntaxTree(null,
new List<ObjectNode>()
{
new RootObjectNode("Window", null, new List<PropertyNode>() { new PropertyNode("Title", new StringNode("Hello")) })
});
analyzer.Analyze(st);
}
public void CtorWrongCountOfArgs2Test()
{
var st = new SyntaxTree(null,
new List<ObjectNode>()
{
new RootObjectNode("Uri")
});
analyzer.Analyze(st);
}
public void PropNotFoundTest()
{
var st = new SyntaxTree(null,
new List<ObjectNode>()
{
new RootObjectNode("Window", null, new List<PropertyNode>() { new PropertyNode("hello", new StringNode("hello")) })
});
analyzer.Analyze(st);
}
private void CheckCtor(SyntaxTree tree, Type objType, ObjectNode objNode)
{
ConstructorInfo ctor;
List<IValueNode> args = null;
if (objNode.ConstructorArguments != null)
args = objNode.ConstructorArguments.ToList();
if (objNode.ConstructorArguments == null || args.Count == 0)
{
ctor = objType.GetConstructor(Type.EmptyTypes);
if (ctor != null)
return;
}
else
{
var types = new Type[args.Count];
var strType = typeof(string);
var doubleType = typeof(double);
for (int i = 0; i < types.Length; i++)
{
var t = args[0];
var refType = t as ReferenceNode;
if (refType != null)
{
types[i] = CheckType(refType.Type);
}
else if (t is StringNode)
{
types[i] = strType;
}
else if (t is NumberNode)
{
types[i] = doubleType;
}
else if (t is EnumNode)
{
types[i] = CheckType(((EnumNode)t).Type);
}
else
{
// todo: error message
throw new EdgeParserException();
}
}
ctor = objType.GetConstructor(types);
if (ctor != null)
return;
// ctor type inference
// todo: refactor!!!
var avaliableCtors = objType.GetConstructors()
.Select(t => t.GetParameters())
.Where(t => t.Length == types.Length)
.ToArray();
var uriType = typeof(Uri);
for (int i = 0; i < avaliableCtors.Length && ctor == null; i++)
{
var currentCtor = avaliableCtors[i];
for (int j = 0; j < currentCtor.Length && ctor == null; j++)
{
if (currentCtor[j].ParameterType == uriType && types[j] == strType)
{
types[j] = uriType;
// id
var urlStrType = char.ToLowerInvariant(uriType.Name[0]) + uriType.Name.Substring(1);
string id = null;
for (int k = 1; k < int.MaxValue; k++)
{
id = urlStrType + k;
if (!tree.Objects.Any(obj => obj.Id == id))
break;
}
if (id == null)
// todo: message
throw new EdgeAnalyzerException();
tree.AddObject(new ObjectNode(uriType.Name, id, new[] { args[j] }));
args[j] = new ReferenceNode(id, uriType.Name);
ctor = objType.GetConstructor(types);
}
}
}
// todo: fix
if (ctor != null)
{
objNode.ConstructorArguments = args;
return;
}
}
// todo: error message
throw new EdgeAnalyzerException();
}
public void CtorWrongTypesTest()
{
var st = new SyntaxTree(null,
new List<ObjectNode>()
{
new RootObjectNode("Uri", new List<IValueNode>() { new NumberNode(1) })
});
analyzer.Analyze(st);
}
public void ObjectWithTwoRoot()
{
var st = new SyntaxTree(null,
new List<ObjectNode>()
{
new RootObjectNode("Window"),
new RootObjectNode("Window")
});
analyzer.Analyze(st);
}
public void CtorTest()
{
var st = new SyntaxTree(null,
new List<ObjectNode>
{
new RootObjectNode("Uri", new List<IValueNode>() { new StringNode("icon.ico") })
});
analyzer.Analyze(st);
}
public void ObjectWithoutRoot()
{
var st = new SyntaxTree(null,
new List<ObjectNode>
{
new ObjectNode("Window", "hello")
});
analyzer.Analyze(st);
}
public void ObjectsWithSameId()
{
var st = new SyntaxTree(null,
new List<ObjectNode>()
{
new ObjectNode("Window", "w1"),
new ObjectNode("Window", "w1")
});
analyzer.Analyze(st);
}
public void NullNamespacesTest()
{
var st = new SyntaxTree(null,
new List<ObjectNode>()
{
new RootObjectNode("Window")
});
analyzer.Analyze(st);
}
private void Test(IEnumerable<IToken> tokens, SyntaxTree expected)
{
lexer.Tokens = tokens;
var tree = parser.Parse("-- // --");
Assert.AreEqual(expected, tree);
}
private void CheckObjects(SyntaxTree tree)
{
var objs = tree.Objects.ToList();
if (objs.Count == 0)
// todo: error message
throw new ArgumentException();
if (objs.Count(obj => obj is RootObjectNode) != 1)
// todo: error message
throw new EdgeAnalyzerException();
ChechAllIDs(objs);
foreach (var obj in objs)
CheckObject(tree, obj);
}
public void PropEnumTypeTest()
{
var st = new SyntaxTree(null,
new List<ObjectNode>()
{
new RootObjectNode("Window", null, new List<PropertyNode>() { new PropertyNode("WindowState", new EnumNode("WindowState", "Normal")) })
});
analyzer.Analyze(st);
}
public void CtorWrongCountOfArgsTest()
{
var st = new SyntaxTree(null,
new List<ObjectNode>()
{
new RootObjectNode("Int32", new List<IValueNode>() { new StringNode("icon.ico"), new StringNode("hello") })
});
analyzer.Analyze(st);
}
public void CtorTypeInferenceTest()
{
var st = new SyntaxTree(null,
new List<ObjectNode>
{
new RootObjectNode("BitmapImage", new List<IValueNode>() { new StringNode("icon.ico") })
});
analyzer.Analyze(st);
}
public void PropIsNotArrayTest()
{
var st = new SyntaxTree(null,
new List<ObjectNode>()
{
new RootObjectNode("Window",
new List<PropertyNode>()
{
new PropertyNode("Title",
new ArrayNode("TextBox",
new IValueNode[]
{
new ReferenceNode("tb1", "TextBox"),
new ReferenceNode("tb2", "TextBox")
}))
}),
new ObjectNode("TextBox", "tb1"),
new ObjectNode("TextBox", "tb2")
});
analyzer.Analyze(st);
}
private void CheckObject(SyntaxTree tree, ObjectNode obj)
{
var type = CheckType(obj.Type);
CheckCtor(tree, type, obj);
CheckProperties(type, obj.Properties);
}
public void PropIsNotEnumValueTest()
{
var st = new SyntaxTree(null,
new List<ObjectNode>()
{
new RootObjectNode("Window", null, new List<PropertyNode>() { new PropertyNode("WindowState", new EnumNode("WindowState", "Hello")) })
});
analyzer.Analyze(st);
}
public void PropIsNotNumberTypeTest()
{
var st = new SyntaxTree(null,
new List<ObjectNode>()
{
new RootObjectNode("Window", null, new List<PropertyNode>() { new PropertyNode("Title", new NumberNode(1024)) })
});
analyzer.Analyze(st);
}
private string CreateRootObject(SyntaxTree tree, string @class, string @namespace)
{
var sb = new StringBuilder();
sb.AppendFormat("namespace {0}", @namespace).Append(nl)
.Append('{').Append(nl).Append(nl)
.AppendFormat("public partial class {0} : {1}", @class, tree.RootObject.Type).Append(nl)
.Append('{').Append(nl).Append(nl);
if (tree != null)
sb.Append(CreateMembers(tree.Objects)).Append(nl);
sb.Append(CreateInitMethod(tree.Objects));
sb.Append('}').Append(nl).Append(nl)
.Append('}');
return sb.ToString();
}
