public void Learn(
List <string> seedPaths, LearningExperiment exp, ICollection <string> projectPaths)
{
var ret = LearnWithoutClearing(seedPaths, exp, projectPaths);
Assert.That(ret.ClassificationResult.WrongVectorCount, Is.EqualTo(0));
}
private void InitializeModeMenu()
{
var menuItems = new List <ToolStripMenuItem>();
var exps = new LearningExperiment[] {
new JavaComplexStatementExperiment(),
new JavaSuperComplexBranchExperiment(),
};
foreach (var exp in exps)
{
var menuItem = menuItemModes.DropDownItems.Add(
exp.GetType().Name.Contains("Statement")
? "Statement" : "Branch") as ToolStripMenuItem;
menuItems.Add(menuItem);
menuItem.Click += (o, args) => {
_activeExperiment = exp;
foreach (var item in menuItems)
{
item.Checked = false;
}
menuItem.Checked = true;
};
}
menuItems[1].PerformClick();
}
private void VerifySeedAcceptedNodes(
IEnumerable <CstNode> seedCsts, ICollection <CstNode> uppermostSeedAcceptedNodes,
LearningExperiment oracle)
{
var anotherUppermostSeedAcceptedNodes = seedCsts
.SelectMany(cst => LearningExperimentUtil
.GetUppermostNodesByNames(cst, SelectedNodeNames))
.Where(oracle.ProtectedIsAcceptedUsingOracle)
.ToList();
var b1 = !uppermostSeedAcceptedNodes.All(oracle.IsAcceptedUsingOracle);
var b2 = anotherUppermostSeedAcceptedNodes
.Select(node => node.AncestorWithSingleChild())
.Any(e => !uppermostSeedAcceptedNodes.Contains(e));
var b3 = uppermostSeedAcceptedNodes.Count != anotherUppermostSeedAcceptedNodes.Count;
Console.WriteLine("Initial: " + string.Join(", ", oracle.OracleNames));
Console.WriteLine("Learned: " + string.Join(", ", SelectedNodeNames));
if (b1 || b2 || b3)
{
Console.WriteLine("--------------------------------------------------");
foreach (var e in uppermostSeedAcceptedNodes)
{
Console.WriteLine(e);
}
Console.WriteLine("--------------------------------------------------");
foreach (var e in anotherUppermostSeedAcceptedNodes)
{
Console.WriteLine(e);
}
throw new Exception("Wrong Oracle.");
}
}
//[Test, TestCaseSource("TestCases")]
public void Test(LearningExperiment exp, string projectPath)
{
var seedPaths = new List <string> {
Fixture.GetInputCodePath(LangName, "Seed.cs")
};
Learn(seedPaths, exp, projectPath);
}
public void LearnAndApply(
ICollection<string> seedPaths, Tuple<string, string>[] learningSets,
LearningExperiment[] experiments) {
var projectPaths =
learningSets.Take(ProjectCount).Select(
t => {
var url = t.Item1;
var path = Fixture.GetGitRepositoryPath(url);
Git.Clone(path, url);
Git.Checkout(path, t.Item2);
return path;
}).ToList();
var failedCount = 0;
foreach (var exp in experiments) {
var learningResult = LearnWithoutClearing(
seedPaths, exp, projectPaths.Take(ProjectCountToLearn).ToList());
var w = CreateWriter(exp.GetType().Name + "_classifier_" +
ProjectCountToLearn + "_" + ProjectCount + ".txt");
w.WriteLine(learningResult.Classifier.GetClassifierSummary());
w.Flush();
var writer = CreateWriter(exp.GetType().Name + "_apply_" +
ProjectCountToLearn + "_" + ProjectCount + ".csv");
foreach (var projectPath in projectPaths.Skip(ProjectCountToLearn)) {
var codePaths = Directory.GetFiles(projectPath, SearchPattern,
SearchOption.AllDirectories);
writer.Write(DateTime.Now);
writer.Write(",");
writer.Write(projectPath);
writer.Write(",");
var classificationResult = exp.Apply(codePaths, SearchPattern,
learningResult.FeatureEncoder,
learningResult.Classifier, writer);
var features =
learningResult.Classifier.GetAllAcceptingFeatureStrings(
learningResult.FeatureEncoder);
writer.Write(classificationResult.WrongElementCount);
writer.Write(",");
writer.Write(classificationResult.WrongVectorCount);
writer.Write(",");
writer.WriteLine();
writer.Flush();
if (classificationResult.WrongElementCount > 0) {
failedCount++;
PrintWrongResults(classificationResult, learningResult);
}
Console.WriteLine(exp.GetType().Name);
Assert.That(failedCount, Is.EqualTo(0));
}
}
}
public void CalculateMetrics(LearningExperiment exp, string projectPath, int starCount)
{
if (!(exp is JavaSuperComplexBranchExperiment))
{
return;
}
var allPaths =
Directory.GetFiles(projectPath, SearchPattern, SearchOption.AllDirectories)
.ToList();
var allNodes = allPaths.Select(p => Generator.GenerateTreeFromCodePath(p))
.SelectMany(r => r.DescendantsAndSelf());
var statementCount = 0;
var branchCount = 0;
foreach (var node in allNodes)
{
if (node.Name == "statement")
{
switch (node.FirstChild.TokenText)
{
case "if":
case "while":
case "do":
case "switch":
branchCount++;
break;
}
}
else if (node.Name == "conditionalExpression" && node.Children().Skip(1).Any())
{
branchCount++;
}
else if (node.Name == "switchLabel" && node.FirstChild.TokenText == "case")
{
branchCount++;
}
else if (node.Name == "statement" || node.Name == "localVariableDeclarationStatement")
{
statementCount++;
}
}
var writer = Writers[exp.GetType().Name];
writer.Write(statementCount + ",");
writer.Write(branchCount + ",");
writer.WriteLine();
writer.Flush();
}
public static void Create(
CstNode root, List <SelectedFragment> acceptingFragments,
LearningExperiment learningExperiment)
{
foreach (var fragment in acceptingFragments)
{
var rootNode = fragment.SurroundingRange.FindInnermostNode(root);
var node = fragment.Node;
var paths = new HashSet <string>();
var path = node.Name;
paths.Add(path);
while ((node = node.Parent) != rootNode)
{
path = path + "<" + node.Name + node.RuleId;
paths.Add(path);
}
}
}
public SeedNodeSet(
IEnumerable <CstNode> seedNodes, IList <CstNode> seedCsts, LearningExperiment oracle)
{
var uppermostSeedAcceptedNodes = seedNodes
.Select(node => node.AncestorWithSingleChild())
.ToImmutableHashSet();
SelectedNodeNames = SelectNodeNames(uppermostSeedAcceptedNodes)
.ToImmutableHashSet();
AcceptedNodes = CreateAcceptedNodes(uppermostSeedAcceptedNodes)
.ToImmutableHashSet();
if (!AcceptedNodes.Any())
{
throw new Exception("There are no accepted seed nodes!");
}
VerifySeedAcceptedNodes(seedCsts, uppermostSeedAcceptedNodes, oracle);
RejectedNodes = CreateRejectedNodes(seedCsts, AcceptedNodes)
.ToImmutableList();
}
private LearningResult LearnWithoutClearing(
ICollection <string> seedPaths, LearningExperiment exp,
ICollection <string> projectPaths)
{
var writer =
CreateWriter(exp.GetType().Name + "_learn_" + projectPaths.Count() + ".csv");
var codePaths = projectPaths.SelectMany(
projectPath => Directory.GetFiles(
projectPath, SearchPattern, SearchOption.AllDirectories)
).ToList();
writer.Write(DateTime.Now);
writer.Write(",");
writer.Write(projectPaths.First());
writer.Write(",");
var learningResult = exp.Learn(seedPaths, codePaths, SearchPattern, writer);
var classificationResult = learningResult.ClassificationResult;
writer.Write(classificationResult.WrongElementCount);
writer.Write(",");
writer.Write(classificationResult.WrongVectorCount);
writer.Write(",");
writer.WriteLine();
writer.Flush();
if (classificationResult.WrongVectorCount > 0)
{
PrintWrongResults(classificationResult, learningResult);
}
var seedWriter =
CreateWriter(exp.GetType().Name + "_seed_" + projectPaths.Count() + ".txt");
WriteSeedVectors(seedWriter, learningResult);
var featureWriter =
CreateWriter(exp.GetType().Name + "_feature_" + projectPaths.Count() + ".txt");
WriteFeatureStrings(featureWriter, learningResult.Classifier,
learningResult.FeatureEncoder, learningResult.EncodingResult);
return(learningResult);
}
public void CalculateMetrics(LearningExperiment exp, string projectPath, int starCount) {
if (!(exp is JavaSuperComplexBranchExperiment)) {
return;
}
var allPaths =
Directory.GetFiles(projectPath, SearchPattern, SearchOption.AllDirectories)
.ToList();
var allNodes = allPaths.Select(p => Generator.GenerateTreeFromCodePath(p))
.SelectMany(r => r.DescendantsAndSelf());
var statementCount = 0;
var branchCount = 0;
foreach (var node in allNodes) {
if (node.Name == "statement") {
switch (node.FirstChild.TokenText) {
case "if":
case "while":
case "do":
case "switch":
branchCount++;
break;
}
} else if (node.Name == "conditionalExpression" && node.Children().Skip(1).Any()) {
branchCount++;
} else if (node.Name == "switchLabel" && node.FirstChild.TokenText == "case") {
branchCount++;
} else if (node.Name == "statement" || node.Name == "localVariableDeclarationStatement") {
statementCount++;
}
}
var writer = Writers[exp.GetType().Name];
writer.Write(statementCount + ",");
writer.Write(branchCount + ",");
writer.WriteLine();
writer.Flush();
}
//[Test, TestCaseSource("TestCases")]
public void Test(LearningExperiment exp, string projectPath) {
var seedPaths = new List<string> { Fixture.GetInputCodePath(LangName, "Seed.java") };
Learn(seedPaths, exp, projectPath);
}
private LearningResult LearnWithoutClearing(
ICollection<string> seedPaths, LearningExperiment exp,
ICollection<string> projectPaths) {
var writer =
CreateWriter(exp.GetType().Name + "_learn_" + projectPaths.Count() + ".csv");
var codePaths = projectPaths.SelectMany(
projectPath => Directory.GetFiles(
projectPath, SearchPattern, SearchOption.AllDirectories)
).ToList();
writer.Write(DateTime.Now);
writer.Write(",");
writer.Write(projectPaths.First());
writer.Write(",");
var learningResult = exp.Learn(seedPaths, codePaths, SearchPattern, writer);
var classificationResult = learningResult.ClassificationResult;
writer.Write(classificationResult.WrongElementCount);
writer.Write(",");
writer.Write(classificationResult.WrongVectorCount);
writer.Write(",");
writer.WriteLine();
writer.Flush();
if (classificationResult.WrongVectorCount > 0) {
PrintWrongResults(classificationResult, learningResult);
}
var seedWriter =
CreateWriter(exp.GetType().Name + "_seed_" + projectPaths.Count() + ".txt");
WriteSeedVectors(seedWriter, learningResult);
var featureWriter =
CreateWriter(exp.GetType().Name + "_feature_" + projectPaths.Count() + ".txt");
WriteFeatureStrings(featureWriter, learningResult.Classifier,
learningResult.FeatureEncoder, learningResult.EncodingResult);
return learningResult;
}
public void Learn(
List<string> seedPaths, LearningExperiment exp, params string[] projectPaths) {
Learn(seedPaths, exp, (ICollection<string>)projectPaths);
}
public void Learn(
List<string> seedPaths, LearningExperiment exp, ICollection<string> projectPaths) {
var ret = LearnWithoutClearing(seedPaths, exp, projectPaths);
Assert.That(ret.ClassificationResult.WrongVectorCount, Is.EqualTo(0));
}
public void Learn(
List <string> seedPaths, LearningExperiment exp, params string[] projectPaths)
{
Learn(seedPaths, exp, (ICollection <string>)projectPaths);
}
