// note: can save a lot of space by moving this to a static / separate 'ends' hash/flag set
public DictionaryNode(SingleChildNode source)
{
Children = new Dictionary <char, INode> {
[source.NextChar] = source.NextNode
};
End = source.End;
}
public INode Split()
{
INode node = new SingleChildNode();
node.End = true;
return(node);
}
public void ManyChildrenNodeTransform()
{
var builder = new ContainerBuilder();
builder.RegisterType <NodeTransformer>().As <INodeTransformer>();
builder.RegisterType <NodeDescriber>().As <INodeDescriber>();
Container = builder.Build();
using (var scope = Container.BeginLifetimeScope())
{
var nodeDescriber = scope.Resolve <INodeDescriber>();
var nodeTransformer = scope.Resolve <INodeTransformer>();
var testData = new ManyChildrenNode("root",
new ManyChildrenNode("child1",
new ManyChildrenNode("leaf1"),
new ManyChildrenNode("child2",
new ManyChildrenNode("leaf2"))));
var result = nodeTransformer.Transform(testData);
var expected = new SingleChildNode("root",
new TwoChildrenNode("child1",
new NoChildrenNode("leaf1"),
new SingleChildNode("child2",
new NoChildrenNode("leaf2"))));
Assert.AreEqual(nodeDescriber.Describe(expected), nodeDescriber.Describe(result));
}
}
public void DefaultTreeDescribe()
{
var builder = new ContainerBuilder();
builder.RegisterType <NodeTransformer>().As <INodeTransformer>();
builder.RegisterType <NodeDescriber>().As <INodeDescriber>();
Container = builder.Build();
using (var scope = Container.BeginLifetimeScope())
{
var nodeDescriber = scope.Resolve <INodeDescriber>();
var nodeTransformer = scope.Resolve <INodeTransformer>();
var testdata = new SingleChildNode("root",
new TwoChildrenNode("child1",
new NoChildrenNode("leaf1"),
new SingleChildNode("child2",
new NoChildrenNode("leaf2"))));
var result = nodeDescriber.Describe(testdata);
System.IO.StringWriter basetextwriter = new System.IO.StringWriter();
IndentedTextWriter indentwriter = new IndentedTextWriter(basetextwriter, " ");
Dictionary <int, List <string> > outPutDic = new Dictionary <int, List <string> >();
outPutDic.Add(0, new List <string>(new string[] { @"new SingleChildNode(""root""," }));
outPutDic.Add(1, new List <string>(new string[] { @"new TwoChildrenNode(""child1""," }));
outPutDic.Add(2, new List <string>(new string[] { @"new NoChildrenNode(""leaf1""),", @"new SingleChildNode(""child2""," }));
outPutDic.Add(3, new List <string>(new string[] { @"new NoChildrenNode(""leaf2""))))" }));
Utility.WriteLevel(indentwriter, outPutDic);
Assert.AreEqual(basetextwriter.ToString(), result);
}
}
public void Add(char[] word, int start)
{
if (word.Length - start == 0)
{
End = true;
return;
}
char c = word[start];
if (Children == null)
{
Children = new Dictionary <char, INode>();
}
INode target;
if (!Children.TryGetValue(c, out target))
{
target = new SingleChildNode();
Children[c] = target;
}
try
{
target.Add(word, start + 1);
}
catch (MustBeSplitException)
{
Children[c] = target.Split();
Add(word, start);
}
}
// breaks PNode into singlechildnode + remainder
public INode Split()
{
INode next = new SingleChildNode();
next.Add(Chars, 0);
return(next);
}
public void Transform_SingleChildWithNull_ReturnNoChildNode()
{
var Transformr = _container.Resolve <TypeNodeTransformer>();
var testData = new SingleChildNode("root", null);
var result = Transformr.Transform(testData);
Assert.IsTrue(result != null && result.GetType().Name == "NoChildrenNode");
}
public void Describe_SingleChildWithOneLeaf_SingleChildWithOneLeaf()
{
var describer = _container.Resolve <TextNodeDescriber>();
var testData = new SingleChildNode("root", new NoChildrenNode("leaf1"));
var result = describer.Describe(testData);
Assert.IsTrue(result != null && result.Contains("root") && result.Contains("leaf1"));
}
private Node TransformSingleChildNode(SingleChildNode node)
{
Node child = node.Child;
if(child == null)
{
return new NoChildrenNode(node.Name);
}
return node;
}
public void DescribeSingleChildNodeTest()
{
var describer = NodeDescriberFactory.GetDescriber();
var node1 = new SingleChildNode("node1", null);
var node2 = new SingleChildNode("node2", new NoChildrenNode("node2.1"));
Assert.AreEqual("new SingleChildNode(\"node1\")", describer.Describe(node1));
Assert.AreEqual("new SingleChildNode(\"node2\",\n new NoChildrenNode(\"node2.1\"))", describer.Describe(node2));
}
public void Describe_Given_SingleChildNode_Returns_SingleChildNodeDescription()
{
//arrange
var expected = "new SingleChildNode(\"root\",\n" + Indentation + "new NoChildrenNode(\"leaf1\"))";
var testData = new SingleChildNode("root", new NoChildrenNode("leaf1"));
//act
var actual = _nodeDescriber.Describe(testData);
//assert
Assert.AreEqual(expected, actual);
}
public void Transform_Given_ManyChildrenNode_And_OneChild_Returns_SingleChildNode()
{
//arrange
var expected = new SingleChildNode("root",
new NoChildrenNode("leaf"));
var testInput = new ManyChildrenNode("root",
new ManyChildrenNode("leaf"));
//act
var transformer = new NodeTransformer();
var actual = transformer.Transform(testInput);
//assert
Assert.AreEqual(expected, actual);
}
static void Main(string[] args)
{
//INodeDescriber describer = new TextNodeDescriber(4);
//var testData = new SingleChildNode("root", new TwoChildrenNode("child1", new NoChildrenNode("leaf1"), new SingleChildNode("child2", new NoChildrenNode("leaf2"))));
var testData = new SingleChildNode("root", new TwoChildrenNode("child1", new NoChildrenNode("leaf1"), new SingleChildNode("child2", null)));
// testData = new SingleChildNode("root", null);
//var result = describer.Describe(testData);
//Console.WriteLine(result);
//INodeDescriber describer2 = new TextNodeDescriber(4);
//INodeTransformer transformer = new TypeNodeTransformer();
//var transformedData=transformer.Transform(testData);
//var transformedresult=describer2.Describe(transformedData);
//Console.WriteLine(transformedresult);
//INodeWriter writer = new FileNodeWriter();
//var filePath = @"C:\Work\Repository\NodeTreeAnalyzer\test.txt";
//writer.WriteToFileAsync(testData,filePath );
//var persistedText = File.ReadAllText(filePath);
//Console.WriteLine(persistedText);
//configure
var container = new UnityContainer();
container.RegisterType(typeof(INodeDescriber), typeof(TextNodeDescriber));
container.RegisterType(typeof(INodeTransformer), typeof(TypeNodeTransformer));
container.RegisterType(typeof(INodeWriter), typeof(FileNodeWriter));
var describer = container.Resolve <TextNodeDescriber>();
Console.WriteLine(describer.Describe(testData));
var writer = container.Resolve <FileNodeWriter>();
var filePath = @"C:\Work\Repository\NodeTreeAnalyzer\test.txt";
writer.WriteToFileAsync(testData, filePath);
var persistedText = File.ReadAllText(filePath);
Console.WriteLine(persistedText);
Console.Read();
}
/// <summary>
/// Method which transforms the tree of nodes into a matching tree that uses the correct node types
/// </summary>
/// <param name="node">Source node</param>
/// <returns>Transformed node</returns>
public Node Transform(Node node)
{
if (node == null)
{
return(null);
}
if (!(node is ManyChildrenNode))
{
throw new Exception("Node must be of ManyChildrenNode type");
}
Node result = null;
ManyChildrenNode sourceNode = (ManyChildrenNode)node;
Node [] transformedChild = this.TransforChildren(sourceNode);
switch (transformedChild.Length)
{
case 0:
result = new NoChildrenNode(sourceNode.Name);
break;
case 1:
result = new SingleChildNode(
sourceNode.Name,
transformedChild[0]
);
break;
case 2:
result = new TwoChildrenNode(
sourceNode.Name,
transformedChild[0],
transformedChild[1]
);
break;
default:
throw new Exception("Unknown transformation");
}
return(result);
}
public void DescribeTreeTest()
{
var describer = NodeDescriberFactory.GetDescriber();
var node = new SingleChildNode("root",
new TwoChildrenNode("child1",
new NoChildrenNode("leaf1"),
new SingleChildNode("child2",
new NoChildrenNode("leaf2"))));
Assert.AreEqual(
"new SingleChildNode(\"root\",\n" +
" new TwoChildrenNode(\"child1\",\n" +
" new NoChildrenNode(\"leaf1\"),\n" +
" new SingleChildNode(\"child2\",\n" +
" new NoChildrenNode(\"leaf2\"))))",
describer.Describe(node)
);
}
public void Describe_Given_ThreeLevelsOfNestedNodes_Returns_ThreeLevelsOfNestedNodesDescription()
{
//arrange
var expected = "new SingleChildNode(\"root\",\n"
+ Indentation + "new TwoChildrenNode(\"child1\",\n"
+ Indentation + Indentation + "new NoChildrenNode(\"leaf1\"),\n"
+ Indentation + Indentation + "new SingleChildNode(\"child2\",\n"
+ Indentation + Indentation + Indentation + "new NoChildrenNode(\"leaf2\"))))";
var testData = new SingleChildNode("root",
new TwoChildrenNode("child1",
new NoChildrenNode("leaf1"),
new SingleChildNode("child2",
new NoChildrenNode("leaf2"))));
//act
var actual = _nodeDescriber.Describe(testData);
//assert
Assert.AreEqual(expected, actual);
}
public void Transform_Given_ManyChildrenNode_And_ManyChildren_Returns_DerivedNodes()
{
//arrange
var expected = new SingleChildNode("root",
new TwoChildrenNode("child1",
new NoChildrenNode("leaf1"),
new SingleChildNode("child2",
new NoChildrenNode("leaf2"))));
var testInput = new ManyChildrenNode("root",
new ManyChildrenNode("child1",
new ManyChildrenNode("leaf1"),
new ManyChildrenNode("child2",
new ManyChildrenNode("leaf2"))));
//act
var transformer = new NodeTransformer();
var actual = transformer.Transform(testInput);
//assert
Assert.AreEqual(expected, actual);
}
public async Task WriteToFileAsync_Given_MultipleNodes_Writes_To_File_MultipleNodes()
{
//arrange
var filePath = "tester.txt";
var testData = new SingleChildNode("root",
new TwoChildrenNode("child1",
new NoChildrenNode("leaf1"),
new SingleChildNode("child2",
new NoChildrenNode("leaf2"))));
var expected = "new SingleChildNode(\"root\",\n"
+ Indentation + "new TwoChildrenNode(\"child1\",\n"
+ Indentation + Indentation + "new NoChildrenNode(\"leaf1\"),\n"
+ Indentation + Indentation + "new SingleChildNode(\"child2\",\n"
+ Indentation + Indentation + Indentation + "new NoChildrenNode(\"leaf2\"))))";
//act
await _nodeWriter.WriteToFileAsync(testData, filePath);
var actual = File.ReadAllText(filePath, Encoding.Unicode);
//assert
Assert.AreEqual(expected, actual);
}
public async Task WriteToFileAsyncTest()
{
var filePath = "test-tree.txt";
var node = new SingleChildNode("root",
new TwoChildrenNode("child1",
new NoChildrenNode("leaf1"),
new SingleChildNode("child2",
new NoChildrenNode("leaf2"))));
INodeWriter implementation = new NodeWriter();
await implementation.WriteToFileAsync(node, filePath);
var result = File.ReadAllText(filePath);
Assert.AreEqual(
"new SingleChildNode(\"root\",\n" +
" new TwoChildrenNode(\"child1\",\n" +
" new NoChildrenNode(\"leaf1\"),\n" +
" new SingleChildNode(\"child2\",\n" +
" new NoChildrenNode(\"leaf2\"))))",
result
);
}
protected bool Equals(SingleChildNode other)
{
return(Equals(Child, other.Child));
}
// note: can save a lot of space by moving this to a static / separate 'ends' hash/flag set
public SmallDictionaryNode(SingleChildNode source)
{
NextChar1 = source.NextChar;
NextNode1 = source.NextNode;
End = source.End;
}
public Node CreateTransformedNode(Node originNode)
{
var myList = new List <Node>();
var nodeType = originNode.GetType();
//Check the real type of node
var properties = nodeType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
var isManyChild = false;
var nodeCount = 0;
var nodeName = string.Empty;
foreach (var propertyInfo in properties)
{
var propertyValue = propertyInfo.GetValue(originNode, null);
if (propertyValue != null)
{
if (!(propertyValue is ValueType) && !(propertyValue is string))
{
var nodeClassType = typeof(Node);
//if node has IEnumerable type
isManyChild = typeof(IEnumerable).IsAssignableFrom(propertyInfo.PropertyType);
if (isManyChild)
{
foreach (var item in propertyValue as IEnumerable <Node> )
{
if (item != null && nodeClassType.IsAssignableFrom(item.GetType()))
{
nodeCount++;
myList.Add(item);
}
}
}
if (nodeClassType.IsAssignableFrom(propertyInfo.PropertyType))
{
nodeCount++;
myList.Add(propertyValue as Node);
}
}
else
{
nodeName = propertyValue.ToString();
}
}
}
switch (nodeCount)
{
case 0:
originNode = new NoChildrenNode(nodeName);
break;
case 1:
originNode = new SingleChildNode(nodeName, CreateTransformedNode(myList[0]));
break;
case 2:
originNode = new TwoChildrenNode(nodeName, CreateTransformedNode(myList[0]), CreateTransformedNode(myList[1]));
break;
default:
break;
}
return(originNode);
}
public void NodeDescriberTest()
{
// Traverse down and across tree
INodeDescriber implementation = new NodeDescriber(new NodesHelper());
var testData = new SingleChildNode("root",
new TwoChildrenNode("child1",
new NoChildrenNode("leaf1"),
new SingleChildNode("child2",
new NoChildrenNode("leaf2"))));
var result = implementation.Describe(testData);
StringBuilder sb = new StringBuilder();
sb.Append("new SingleChildNode(\"root\","); sb.Append(Environment.NewLine);
sb.Append(tab); sb.Append("new TwoChildrenNode(\"child1\","); sb.Append(Environment.NewLine);
sb.Append(tab); sb.Append(tab); sb.Append("new NoChildrenNode(\"leaf1\"),"); sb.Append(Environment.NewLine);
sb.Append(tab); sb.Append(tab); sb.Append("new SingleChildNode(\"child2\","); sb.Append(Environment.NewLine);
sb.Append(tab); sb.Append(tab); sb.Append(tab); sb.Append("new NoChildrenNode(\"leaf2\"))));");
string expectedResult = sb.ToString();
Assert.AreEqual(expectedResult, result);
// Traverse down tree, back up, then back down
implementation = new NodeDescriber(new NodesHelper());
testData = new SingleChildNode("root",
new ManyChildrenNode("child1",
new SingleChildNode("child2",
new NoChildrenNode("leaf1")),
new NoChildrenNode("leaf2")));
result = implementation.Describe(testData);
sb = new StringBuilder();
sb.Append("new SingleChildNode(\"root\","); sb.Append(Environment.NewLine);
sb.Append(tab); sb.Append("new ManyChildrenNode(\"child1\","); sb.Append(Environment.NewLine);
sb.Append(tab); sb.Append(tab); sb.Append("new SingleChildNode(\"child2\","); sb.Append(Environment.NewLine);
sb.Append(tab); sb.Append(tab); sb.Append(tab); sb.Append("new NoChildrenNode(\"leaf1\")),"); sb.Append(Environment.NewLine);
sb.Append(tab); sb.Append(tab); sb.Append("new NoChildrenNode(\"leaf2\")));");
expectedResult = sb.ToString();
Assert.AreEqual(expectedResult, result);
// Traverse tree, removing null nodes
implementation = new NodeDescriber(new NodesHelper());
var testDataWithNulls = new ManyChildrenNode("root",
new TwoChildrenNode("child1",
null,
new SingleChildNode("leaf1",
null)));
result = implementation.Describe(testDataWithNulls);
sb = new StringBuilder();
sb.Append("new ManyChildrenNode(\"root\","); sb.Append(Environment.NewLine);
sb.Append(tab); sb.Append("new TwoChildrenNode(\"child1\","); sb.Append(Environment.NewLine);
sb.Append(tab); sb.Append(tab); sb.Append("new SingleChildNode(\"leaf1\")));");
expectedResult = sb.ToString();
Assert.AreEqual(expectedResult, result);
}
