public IList <AbstractSyntaxTreeAnalysisLevel> CreateLevels(ref AbstractSyntaxTreeNode expected)
{
var visitor = new AbstractSyntaxTreeAnalysisVisitor();
expected.PreOrder(visitor);
return(visitor.Levels);
}
public int CompareChildren(AbstractSyntaxTreeNode expected, AbstractSyntaxTreeNode actual)
{
int score = 0;
var leftHashtags = expected.Children.Select(node => node.HashTag).ToList();
leftHashtags.Sort();
var rightHashtags = actual.Children.Select(node => node.HashTag).ToList();
rightHashtags.Sort();
var leftIndex = 0;
var rightIndex = 0;
for (; leftIndex < leftHashtags.Count && rightIndex < rightHashtags.Count; rightIndex++)
{
while (leftIndex < leftHashtags.Count && rightHashtags[rightIndex] > leftHashtags[leftIndex])
{
leftIndex++;
}
if (leftIndex < leftHashtags.Count && rightHashtags[rightIndex] == leftHashtags[leftIndex])
{
score++;
leftIndex++;
}
}
return(score);
}
public void EqualOperator_ShouldBeTrueForSameValue()
{
var lhs = new AbstractSyntaxTreeNode(RootValue);
var rhs = new AbstractSyntaxTreeNode(RootValue);
Assert.IsTrue(lhs == rhs);
}
public async Task <SnapshotReport> GenerateImpl(SubmissionData data, string snapshot, Assignment assignment,
AbstractSyntaxTreeNode solutionNode)
{
var studentNode = GetStudentSnapshot(data, snapshot, assignment);
var snapshotMethods = assignment
.Solution
.MethodDeclarations
.Select(methodDeclaration =>
MethodGenerator.Generate(studentNode, solutionNode, methodDeclaration))
.ToList();
var unitTests = await UnitTestGenerator.GenerateResults(data, snapshot,
assignment, snapshotMethods);
var report = new SnapshotSuccessReport()
{
SnapshotMethods = snapshotMethods,
UnitTestResults = unitTests,
};
await SnapshotReports.Add(report);
return(report);
}
public SnapshotMethod Generate(AbstractSyntaxTreeNode studentNode, AbstractSyntaxTreeNode solutionNode, MethodDeclaration method)
{
var studentMethod = GetMethodOrDefault(studentNode, method);
var solutionMethod = GetMethodOrDefault(solutionNode, method);
if (studentMethod == null || solutionMethod == null)
{
return new SnapshotMethod()
{
Declared = false,
MethodDeclaration = method,
}
}
;
return(new SnapshotMethod()
{
Declared = true,
CodeAnalysisMetric = new CodeAnalysisMetric()
{
AbstractSyntaxTreeMetric = AbstractSyntaxTreeMetricCreator.Create(solutionMethod, studentMethod),
BagOfWordsMetric = BagOfWordsMetricCreator.Create(solutionMethod, studentMethod),
},
MethodDeclaration = method
});
}
private AbstractSyntaxTreeMetric RotateNodes(AbstractSyntaxTreeMetric metric, int index,
int nodeIndex, ref IList <AbstractSyntaxTreeAnalysisLevel> level,
AbstractSyntaxTreeNode node)
{
var compareNode = level[index].Nodes[nodeIndex].Node;
for (var i = 0; i < node.Children.Count; i++)
{
var rotatingNode = -1;
for (var j = i; j < compareNode.Children.Count && rotatingNode == -1; j++)
{
if (compareNode.Children[j] == node.Children[i])
{
rotatingNode = j;
}
}
if (i == rotatingNode)
{
continue;
}
if (rotatingNode != -1)
{
compareNode.RemoveAt(rotatingNode);
}
compareNode.InsertAt(i, node.Children[i]);
metric.Rotations++;
}
return(metric);
}
public void NotEqualOperator_ShouldBeFalseForDifferentValue()
{
var lhs = new AbstractSyntaxTreeNode(RootValue);
var rhs = new AbstractSyntaxTreeNode(ChildValue);
Assert.IsTrue(lhs != rhs);
}
public AbstractSyntaxTreeNode GatherCallExpressions(MethodExtractorObj obj, AbstractSyntaxTreeNode methodNode, AbstractSyntaxTreeNode root, string methodHashCode)
{
var hasCodes = new List <string>();
foreach (var callExpressionNode in obj.CallExpressions)
{
var visitor = new AbstractSyntaxTreeWordSearchVisitor(Splitter, "MemberExpr");
callExpressionNode.BreadthFirst(visitor);
if (!visitor.Found)
{
continue;
}
var hashCode = Splitter.Split(visitor.Node.Value).Last();
if (hashCode.Equals(methodHashCode) || hasCodes.Contains(hashCode))
{
continue;
}
hasCodes.Add(hashCode);
var callNode = GetCallNodeOrDefault(root, hashCode);
if (callNode == null)
{
continue;
}
methodNode.Append(callNode);
}
return(methodNode);
}
public AbstractSyntaxTreeNode GetCallNodeOrDefault(AbstractSyntaxTreeNode root, string hashCode)
{
var visitor = new HashCodeExtractorSearchVisitor(Splitter, hashCode);
root.BreadthFirst(visitor);
return(visitor.Node);
}
public void Create_RotationOfSeperateTree()
{
var left = new AbstractSyntaxTreeNode("A");
var branchLeft = new AbstractSyntaxTreeNode("B");
var terminalLeft = new AbstractSyntaxTreeNode("C");
branchLeft.Append(terminalLeft);
var branchRight = new AbstractSyntaxTreeNode("D");
var terminalRight = new AbstractSyntaxTreeNode("E");
branchRight.Append(terminalRight);
left.Append(branchLeft);
left.Append(branchRight);
var right = new AbstractSyntaxTreeNode("A");
right.Append(branchRight.CopyDeep());
right.Append(branchLeft.CopyDeep());
var metric = Creator.Create(left, right);
Assert.AreEqual(
new AbstractSyntaxTreeMetric()
{
Insertations = 0,
Deletions = 0,
Rotations = 1
},
metric
);
}
public void Visit(AbstractSyntaxTreeNode node)
{
if (node.Value.Equals(Looking))
{
Found = true;
}
}
public SnapshotMethod Generate(AbstractSyntaxTreeNode student, AbstractSyntaxTreeNode solution, MethodDeclaration method)
{
return(new SnapshotMethod()
{
Declared = true,
});
}
public bool ContainsDefinitionData(AbstractSyntaxTreeNode node)
{
var visitor = new AbstractSyntaxTreeWordSearchVisitor(Splitter, "DefinitionData");
node.BreadthFirst(visitor);
return(visitor.Found);
}
protected void BaseInit()
{
Root = new AbstractSyntaxTreeNode("1");
var leftRootChild = new AbstractSyntaxTreeNode("2");
var rightRootChild = new AbstractSyntaxTreeNode("3");
leftRootChild.Append(new AbstractSyntaxTreeNode("4"));
leftRootChild.Append(new AbstractSyntaxTreeNode("5"));
rightRootChild.Append(new AbstractSyntaxTreeNode("6"));
Root.Append(leftRootChild);
Root.Append(rightRootChild);
PreOrderExpected = new[]
{
"1", "2", "4", "5", "3", "6"
};
PostOrderExpected = new[]
{
"4", "5", "2", "6", "3", "1"
};
BreadthFirstExpected = new[]
{
"1", "2", "3", "4", "5", "6"
};
}
public AbstractSyntaxTreeNode ExtractOrDefault(AbstractSyntaxTreeNode root, MethodDeclaration methodDeclaration)
{
if (ReturnNull)
{
return(null);
}
return(root);
}
public void Create_IdenticalTerminalNodesShouldBeNoDifference()
{
var left = new AbstractSyntaxTreeNode("A");
var right = new AbstractSyntaxTreeNode("A");
var metric = Creator.Create(left, right);
Assert.AreEqual(new AbstractSyntaxTreeMetric(), metric);
}
public void Search_ShouldNotFindTwo()
{
var root = new AbstractSyntaxTreeNode("root");
root.Append(new AbstractSyntaxTreeNode("1 one"));
var visitor = new AbstractSyntaxTreeWordSearchVisitor(Splitter, "two");
root.PreOrder(visitor);
Assert.IsNull(visitor.Node);
}
public void Visit(AbstractSyntaxTreeNode node)
{
var values = Splitter.Split(node.Value);
if (values.Length < 1 || !values[0].Equals("CallExpr"))
{
return;
}
ExtractorObj.CallExpressions.Add(node);
}
public void Visit(AbstractSyntaxTreeNode node)
{
var values = Splitter.Split(node.Value);
if (values.Length < 1 || !values[0].Equals(Type))
{
return;
}
ExtractorObj.Methods.Add(node);
}
public void Search_ShouldFindTheNodeWithOne()
{
var root = new AbstractSyntaxTreeNode("root");
root.Append(new AbstractSyntaxTreeNode("1 one"));
var visitor = new AbstractSyntaxTreeWordSearchVisitor(Splitter, "one");
root.PreOrder(visitor);
Assert.IsTrue(visitor.Node.Value.Contains("1"));
}
public void Visit(AbstractSyntaxTreeNode node)
{
var values = Splitter.Split(node.Value);
if (values.Length < 2 || !values[1].Equals(HashCode))
{
return;
}
Node = node;
Found = true;
}
public AbstractSyntaxTreeNode Extract(AbstractSyntaxTreeNode root, string name)
{
if (Type == PreAssignmentReport.PreAssignmentReportTypes.NoClassFailure)
{
throw new EngineAssignmentExceptionData()
{
Report = new PreAssignmentNoClassFailureReport()
}
}
;
return(new AbstractSyntaxTreeNode("Root"));
}
public AbstractSyntaxTreeNode Extract(AbstractSyntaxTreeNode root, string name)
{
var visitor = new ClassExtractorDeclVisitor(new ClassExtractorObj(), Splitter);
root.PreOrder(visitor);
var classNode = GatherDeclInformation(name, visitor.ExtractorObj, out var hashCode);
var node = GatherMethodDeclaration(classNode, visitor.ExtractorObj, hashCode);
return(node);
}
public AbstractSyntaxTreeNode GatherMethodDeclaration(AbstractSyntaxTreeNode classNode, ClassExtractorObj obj, string hashCode)
{
var root = new AbstractSyntaxTreeNode("Root");
root.Append(classNode);
foreach (var node in obj.CxxMethodDecls.Where(wrapper => IsDefinedClassMethod(wrapper, hashCode)))
{
root.Append(node);
}
return(root);
}
public AbstractSyntaxTreeNode GetMethodOrDefault(AbstractSyntaxTreeNode node, MethodDeclaration method)
{
var methodNode = AbstractSyntaxTreeMethodExtractor.ExtractOrDefault(node, method);
if (methodNode == null)
{
return(null);
}
var filter = new AbstractSyntaxTreeFilterVisitor(LineFilter);
methodNode.PostOrder(filter);
return(methodNode);
}
public void Visit(AbstractSyntaxTreeNode node)
{
var words = _splitter.Split(node.Value);
foreach (var word in words)
{
Content += " " + word + " ";
if (!Lexicon.Contains(word))
{
Lexicon.Add(word);
}
}
}
public void Visit(AbstractSyntaxTreeNode node)
{
while (Levels.Count < node.Height)
{
Levels.Add(new AbstractSyntaxTreeAnalysisLevel
{
Height = Levels.Count
});
}
Levels[node.Height - 1].Nodes.Add(
new AbstractSyntaxTreeAnalysisNodeWrapper()
{
Node = node,
});
}
public void Create_OneDeletionsOfNode()
{
var left = new AbstractSyntaxTreeNode("A");
left.Append(new AbstractSyntaxTreeNode("B"));
var right = left.CopyDeep();
left.Append(new AbstractSyntaxTreeNode("C"));
var metric = Creator.Create(left, right);
Assert.AreEqual(new AbstractSyntaxTreeMetric()
{
Deletions = 1,
}, metric);
}
public void Create_IdenticalTreeShouldBeNoDifference()
{
var left = new AbstractSyntaxTreeNode("A");
var terminal = new AbstractSyntaxTreeNode("B");
var branch = new AbstractSyntaxTreeNode("C");
branch.Append(terminal);
left.Append(branch);
left.Append(terminal.CopyDeep());
var right = left.CopyDeep();
var metric = Creator.Create(left, right);
Assert.AreEqual(new AbstractSyntaxTreeMetric(), metric);
}
public string GetMethodHashCodeOrDefault(AbstractSyntaxTreeNode node, string type)
{
var visitor = new AbstractSyntaxTreeWordSearchVisitor(Splitter, type);
node.BreadthFirst(visitor);
if (!visitor.Found)
{
return(null);
}
var values = Splitter.Split(visitor.Node.Value);
return(values.Length > 1 ? values[1] : null);
}
