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); }
//[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); }