public void Describe_NoChildNode_OutputNoChildNode()
{
var describer = _container.Resolve <TextNodeDescriber>();
var testData = new NoChildrenNode("leaf1");
var result = describer.Describe(testData);
Assert.IsTrue(result != null && result.Contains("leaf1"));
}
public void Transform_NoChildNode_ReturnChildNode()
{
var Transformr = _container.Resolve <TypeNodeTransformer>();
var testData = new NoChildrenNode("leaf1");
var result = Transformr.Transform(testData);
Assert.IsTrue(result != null && result.GetType().Name == "NoChildrenNode");
}
public void DescribeNoChildrenNodeTest()
{
var describer = NodeDescriberFactory.GetDescriber();
var node1 = new NoChildrenNode(null);
var node2 = new NoChildrenNode("node2");
Assert.AreEqual("new NoChildrenNode(\"\")", describer.Describe(node1));
Assert.AreEqual("new NoChildrenNode(\"node2\")", describer.Describe(node2));
}
public void Describe_Given_NoChildrenNode_Returns_NoChildrenNodeDescription()
{
//arrange
var expected = "new NoChildrenNode(\"root\")";
var testInput = new NoChildrenNode("root");
//act
var actual = _nodeDescriber.Describe(testInput);
//assert
Assert.AreEqual(expected, actual);
}
public void Transform_Given_ManyChildrenNode_And_NoChildren_Returns_NoChildrenNode()
{
//arrange
var expected = new NoChildrenNode("root");
var testInput = new ManyChildrenNode("root");
//act
var transformer = new NodeTransformer();
var actual = transformer.Transform(testInput);
//assert
Assert.AreEqual(expected, actual);
}
public async Task WriteToFileAsync_Given_NoChildrenNode_Writes_To_File_NoChildrenNode()
{
//arrange
var filePath = "tester.txt";
var testData = new NoChildrenNode("root");
var expected = "new NoChildrenNode(\"root\")";
//act
await _nodeWriter.WriteToFileAsync(testData, filePath);
var actual = File.ReadAllText(filePath, Encoding.Unicode);
//assert
Assert.AreEqual(expected, actual);
}
/// <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 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);
}
