public void TestFindMethodCalls_Nested() {
File.Copy(@"..\..\TestInputs\nested_method_calls.cpp", Path.Combine(TestDir, "nested_method_calls.cpp"));
using(var dataProj = new DataProject<CompleteWorkingSet>(DataDir, TestDir, SrcMLDir)) {
dataProj.Update();
NamespaceDefinition globalScope;
MethodCall[] expected;
Assert.That(dataProj.WorkingSet.TryObtainReadLock(Timeout.Infinite, out globalScope));
try {
expected = new[] {
globalScope.FindExpressions<MethodCall>(true).First(mc => mc.Name == "ToString"),
globalScope.FindExpressions<MethodCall>(true).First(mc => mc.Name == "SomeMethodCall"),
globalScope.FindExpressions<MethodCall>(true).First(mc => mc.Name == "printf")
};
} finally {
dataProj.WorkingSet.ReleaseReadLock();
}
var query = new FindMethodCallsAtLocationQuery(dataProj.WorkingSet, Timeout.Infinite);
var testFile = Path.GetFullPath(Path.Combine(TestDir, "nested_method_calls.cpp"));
var actual = query.Execute(new SourceLocation(testFile, 4, 41));
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Length, actual.Count);
for(int i = 0; i < expected.Length; i++) {
Assert.AreSame(expected[i], actual[i]);
}
}
}
public void TestFindMethodCalls_Nested()
{
File.Copy(@"..\..\TestInputs\nested_method_calls.cpp", Path.Combine(TestDir, "nested_method_calls.cpp"));
using (var dataProj = new DataProject <CompleteWorkingSet>(DataDir, TestDir, SrcMLDir)) {
dataProj.Update();
NamespaceDefinition globalScope;
MethodCall[] expected;
Assert.That(dataProj.WorkingSet.TryObtainReadLock(Timeout.Infinite, out globalScope));
try {
expected = new[] {
globalScope.FindExpressions <MethodCall>(true).First(mc => mc.Name == "ToString"),
globalScope.FindExpressions <MethodCall>(true).First(mc => mc.Name == "SomeMethodCall"),
globalScope.FindExpressions <MethodCall>(true).First(mc => mc.Name == "printf")
};
} finally {
dataProj.WorkingSet.ReleaseReadLock();
}
var query = new FindMethodCallsAtLocationQuery(dataProj.WorkingSet, Timeout.Infinite);
var testFile = Path.GetFullPath(Path.Combine(TestDir, "nested_method_calls.cpp"));
var actual = query.Execute(new SourceLocation(testFile, 4, 41));
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Length, actual.Count);
for (int i = 0; i < expected.Length; i++)
{
Assert.AreSame(expected[i], actual[i]);
}
}
}
public void TestOverloadedMethodCallResolutionWithCallingObject()
{
File.Copy(@"..\..\TestInputs\csharp_overload_callingobj.cs", Path.Combine(TestDir, "csharp_overload_callingobj.cs"));
File.Copy(@"..\..\TestInputs\csharp_overload_calls.cs", Path.Combine(TestDir, "csharp_overload_calls.cs"));
using (var project = new DataProject <CompleteWorkingSet>(DataDir, TestDir, SrcMLDir)) {
project.Update();
var query = new StatementForLocationQuery <MethodDefinition>(project.WorkingSet, Timeout.Infinite);
var startOffoo0 = new SourceLocation(Path.GetFullPath(Path.Combine(TestDir, "csharp_overload_calls.cs")), 11, 25);
var startOffoo1 = new SourceLocation(Path.GetFullPath(Path.Combine(TestDir, "csharp_overload_calls.cs")), 13, 25);
var startOfRunFoo0 = new SourceLocation(Path.GetFullPath(Path.Combine(TestDir, "csharp_overload_callingobj.cs")), 5, 25);
var startOfRunFoo1 = new SourceLocation(Path.GetFullPath(Path.Combine(TestDir, "csharp_overload_callingobj.cs")), 7, 25);
var foo0 = query.Execute(startOffoo0);
Assert.AreEqual("foo", foo0.Name);
Assert.AreEqual(0, foo0.Parameters.Count);
var foo1 = query.Execute(startOffoo1);
Assert.AreEqual("foo", foo1.Name);
Assert.AreEqual(1, foo1.Parameters.Count);
var runFoo0 = query.Execute(startOfRunFoo0);
Assert.AreEqual("runFoo0", runFoo0.Name);
var runFoo1 = query.Execute(startOfRunFoo1);
Assert.AreEqual("runFoo1", runFoo1.Name);
Assert.That(runFoo0.ContainsCallTo(foo0));
Assert.That(!runFoo0.ContainsCallTo(foo1));
Assert.That(runFoo1.ContainsCallTo(foo1));
Assert.That(!runFoo1.ContainsCallTo(foo0));
var callNoParams = runFoo0.FindExpressions <MethodCall>(true).FirstOrDefault();
var matches = callNoParams.FindMatches().ToList();
Assert.AreEqual(1, matches.Count);
Assert.AreSame(foo0, matches[0]);
var callWithParam = runFoo1.FindExpressions <MethodCall>(true).FirstOrDefault();
matches = callWithParam.FindMatches().ToList();
Assert.AreEqual(1, matches.Count);
Assert.AreSame(foo1, matches[0]);
}
}
public void TestFindScopeForAdjacentMethods()
{
File.Copy(@"..\..\TestInputs\adjacent_methods.cpp", Path.Combine(TestDir, "adjacent_methods.cpp"));
using (var dataProj = new DataProject <CompleteWorkingSet>(DataDir, TestDir, SrcMLDir)) {
dataProj.Update();
NamespaceDefinition globalScope;
MethodDefinition mainMethod;
MethodDefinition fooMethod;
Assert.That(dataProj.WorkingSet.TryObtainReadLock(Timeout.Infinite, out globalScope));
try {
mainMethod = globalScope.GetDescendants <MethodDefinition>().First(md => md.Name == "main");
fooMethod = globalScope.GetDescendants <MethodDefinition>().First(md => md.Name == "Foo");
} finally {
dataProj.WorkingSet.ReleaseReadLock();
}
var query = new StatementForLocationQuery(dataProj.WorkingSet, Timeout.Infinite);
var testFile = Path.GetFullPath(Path.Combine(TestDir, "adjacent_methods.cpp"));
var startOfMain = new SourceLocation(testFile, 1, 1);
var locationInMain = new SourceLocation(testFile, 1, 11);
Assert.That(mainMethod.PrimaryLocation.Contains(startOfMain));
Assert.That(mainMethod.PrimaryLocation.Contains(locationInMain));
Assert.AreSame(mainMethod, query.Execute(startOfMain));
Assert.AreSame(mainMethod, query.Execute(locationInMain));
var startOfFoo = new SourceLocation(testFile, 3, 1);
var locationInFoo = new SourceLocation(testFile, 3, 11);
Assert.That(fooMethod.PrimaryLocation.Contains(startOfFoo));
Assert.That(fooMethod.PrimaryLocation.Contains(locationInFoo));
Assert.AreSame(fooMethod, query.Execute(startOfFoo));
Assert.AreSame(fooMethod, query.Execute(locationInFoo));
var lineBetweenMethods = new SourceLocation(testFile, 2, 1);
Assert.That(mainMethod.PrimaryLocation.Contains(lineBetweenMethods));
Assert.IsFalse(fooMethod.PrimaryLocation.Contains(lineBetweenMethods));
Assert.AreSame(mainMethod, query.Execute(lineBetweenMethods));
}
}
public void TestQueryDuringUpdate()
{
var sourceFolder = "TestQueryDuringUpdate";
var dataFolder = "TestQueryDuringUpdate_Data";
Directory.CreateDirectory(sourceFolder);
string fooSourcePath = Path.Combine(sourceFolder, "foo.cpp");
string barSourcePath = Path.Combine(sourceFolder, "bar.cpp");
var fooRevisions = new string[] { "void foo() { }", "void foo() { bar(); }" };
File.WriteAllText(fooSourcePath, fooRevisions[1]);
File.WriteAllText(barSourcePath, "void bar() { }");
int iterations = 1000;
using (var project = new DataProject <CompleteWorkingSet>(dataFolder, sourceFolder, "SrcML")) {
project.Update();
project.StartMonitoring();
var developer = new Task(() => {
for (int i = 0; i < iterations; i++)
{
File.WriteAllText(fooSourcePath, fooRevisions[i % 2]);
}
});
developer.Start();
Assert.DoesNotThrow(() => {
for (int i = 0; i < iterations; i++)
{
var foo = GetMethodWithName(project.WorkingSet, 500, "foo");
var bar = GetMethodWithName(project.WorkingSet, 500, "bar");
foo.ContainsCallTo(bar);
if (i % 10 == 0 && i > 0)
{
Console.WriteLine("Finished {0} iterations", i);
}
}
});
developer.Wait();
}
}
public void TestFindMethodCalls_Simple() {
File.Copy(@"..\..\TestInputs\function_def.cpp", Path.Combine(TestDir, "function_def.cpp"));
using(var dataProj = new DataProject<CompleteWorkingSet>(DataDir, TestDir, SrcMLDir)) {
dataProj.Update();
NamespaceDefinition globalScope;
MethodCall expected;
Assert.That(dataProj.WorkingSet.TryObtainReadLock(Timeout.Infinite, out globalScope));
try {
expected = globalScope.FindExpressions<MethodCall>(true).First(mc => mc.Name == "MyFunction");
} finally {
dataProj.WorkingSet.ReleaseReadLock();
}
var query = new FindMethodCallsAtLocationQuery(dataProj.WorkingSet, Timeout.Infinite);
var testFile = Path.GetFullPath(Path.Combine(TestDir, "function_def.cpp"));
var actual = query.Execute(new SourceLocation(testFile, 12, 20));
Assert.IsNotNull(actual);
Assert.AreEqual(1, actual.Count);
Assert.AreSame(expected, actual[0]);
}
}
public void TestQueryDuringUpdate() {
var sourceFolder = "TestQueryDuringUpdate";
var dataFolder = "TestQueryDuringUpdate_Data";
Directory.CreateDirectory(sourceFolder);
string fooSourcePath = Path.Combine(sourceFolder, "foo.cpp");
string barSourcePath = Path.Combine(sourceFolder, "bar.cpp");
var fooRevisions = new string[] { "void foo() { }", "void foo() { bar(); }" };
File.WriteAllText(fooSourcePath, fooRevisions[1]);
File.WriteAllText(barSourcePath, "void bar() { }");
int iterations = 1000;
using(var project = new DataProject<CompleteWorkingSet>(dataFolder, sourceFolder, "SrcML")) {
project.Update();
project.StartMonitoring();
var developer = new Task(() => {
for(int i = 0; i < iterations; i++) {
File.WriteAllText(fooSourcePath, fooRevisions[i % 2]);
}
});
developer.Start();
Assert.DoesNotThrow(() => {
for(int i = 0; i < iterations; i++) {
var foo = GetMethodWithName(project.WorkingSet, 500, "foo");
var bar = GetMethodWithName(project.WorkingSet, 500, "bar");
foo.ContainsCallTo(bar);
if(i % 10 == 0 && i > 0) {
Console.WriteLine("Finished {0} iterations", i);
}
}
});
developer.Wait();
}
}
public void TestFindMethodCalls_Simple()
{
File.Copy(@"..\..\TestInputs\function_def.cpp", Path.Combine(TestDir, "function_def.cpp"));
using (var dataProj = new DataProject <CompleteWorkingSet>(DataDir, TestDir, SrcMLDir)) {
dataProj.Update();
NamespaceDefinition globalScope;
MethodCall expected;
Assert.That(dataProj.WorkingSet.TryObtainReadLock(Timeout.Infinite, out globalScope));
try {
expected = globalScope.FindExpressions <MethodCall>(true).First(mc => mc.Name == "MyFunction");
} finally {
dataProj.WorkingSet.ReleaseReadLock();
}
var query = new FindMethodCallsAtLocationQuery(dataProj.WorkingSet, Timeout.Infinite);
var testFile = Path.GetFullPath(Path.Combine(TestDir, "function_def.cpp"));
var actual = query.Execute(new SourceLocation(testFile, 12, 20));
Assert.IsNotNull(actual);
Assert.AreEqual(1, actual.Count);
Assert.AreSame(expected, actual[0]);
}
}
public void TestFindScopeForAdjacentMethods() {
File.Copy(@"..\..\TestInputs\adjacent_methods.cpp", Path.Combine(TestDir, "adjacent_methods.cpp"));
using(var dataProj = new DataProject<CompleteWorkingSet>(DataDir, TestDir, SrcMLDir)) {
dataProj.Update();
NamespaceDefinition globalScope;
MethodDefinition mainMethod;
MethodDefinition fooMethod;
Assert.That(dataProj.WorkingSet.TryObtainReadLock(Timeout.Infinite, out globalScope));
try {
mainMethod = globalScope.GetDescendants<MethodDefinition>().First(md => md.Name == "main");
fooMethod = globalScope.GetDescendants<MethodDefinition>().First(md => md.Name == "Foo");
} finally {
dataProj.WorkingSet.ReleaseReadLock();
}
var query = new StatementForLocationQuery(dataProj.WorkingSet, Timeout.Infinite);
var testFile = Path.GetFullPath(Path.Combine(TestDir, "adjacent_methods.cpp"));
var startOfMain = new SourceLocation(testFile, 1, 1);
var locationInMain = new SourceLocation(testFile, 1, 11);
Assert.That(mainMethod.PrimaryLocation.Contains(startOfMain));
Assert.That(mainMethod.PrimaryLocation.Contains(locationInMain));
Assert.AreSame(mainMethod, query.Execute(startOfMain));
Assert.AreSame(mainMethod, query.Execute(locationInMain));
var startOfFoo = new SourceLocation(testFile, 3, 1);
var locationInFoo = new SourceLocation(testFile, 3, 11);
Assert.That(fooMethod.PrimaryLocation.Contains(startOfFoo));
Assert.That(fooMethod.PrimaryLocation.Contains(locationInFoo));
Assert.AreSame(fooMethod, query.Execute(startOfFoo));
Assert.AreSame(fooMethod, query.Execute(locationInFoo));
var lineBetweenMethods = new SourceLocation(testFile, 2, 1);
Assert.That(mainMethod.PrimaryLocation.Contains(lineBetweenMethods));
Assert.IsFalse(fooMethod.PrimaryLocation.Contains(lineBetweenMethods));
Assert.AreSame(mainMethod, query.Execute(lineBetweenMethods));
}
}
public void TestOverloadedMethodCallResolutionWithCallingObject() {
File.Copy(@"..\..\TestInputs\csharp_overload_callingobj.cs", Path.Combine(TestDir, "csharp_overload_callingobj.cs"));
File.Copy(@"..\..\TestInputs\csharp_overload_calls.cs", Path.Combine(TestDir, "csharp_overload_calls.cs"));
using(var project = new DataProject<CompleteWorkingSet>(DataDir, TestDir, SrcMLDir)) {
project.Update();
var query = new StatementForLocationQuery<MethodDefinition>(project.WorkingSet, Timeout.Infinite);
var startOffoo0 = new SourceLocation(Path.GetFullPath(Path.Combine(TestDir, "csharp_overload_calls.cs")), 11, 25);
var startOffoo1 = new SourceLocation(Path.GetFullPath(Path.Combine(TestDir, "csharp_overload_calls.cs")), 13, 25);
var startOfRunFoo0 = new SourceLocation(Path.GetFullPath(Path.Combine(TestDir, "csharp_overload_callingobj.cs")), 5, 25);
var startOfRunFoo1 = new SourceLocation(Path.GetFullPath(Path.Combine(TestDir, "csharp_overload_callingobj.cs")), 7, 25);
var foo0 = query.Execute(startOffoo0);
Assert.AreEqual("foo", foo0.Name);
Assert.AreEqual(0, foo0.Parameters.Count);
var foo1 = query.Execute(startOffoo1);
Assert.AreEqual("foo", foo1.Name);
Assert.AreEqual(1, foo1.Parameters.Count);
var runFoo0 = query.Execute(startOfRunFoo0);
Assert.AreEqual("runFoo0", runFoo0.Name);
var runFoo1 = query.Execute(startOfRunFoo1);
Assert.AreEqual("runFoo1", runFoo1.Name);
Assert.That(runFoo0.ContainsCallTo(foo0));
Assert.That(!runFoo0.ContainsCallTo(foo1));
Assert.That(runFoo1.ContainsCallTo(foo1));
Assert.That(!runFoo1.ContainsCallTo(foo0));
var callNoParams = runFoo0.FindExpressions<MethodCall>(true).FirstOrDefault();
var matches = callNoParams.FindMatches().ToList();
Assert.AreEqual(1, matches.Count);
Assert.AreSame(foo0, matches[0]);
var callWithParam = runFoo1.FindExpressions<MethodCall>(true).FirstOrDefault();
matches = callWithParam.FindMatches().ToList();
Assert.AreEqual(1, matches.Count);
Assert.AreSame(foo1, matches[0]);
}
}
/// <summary>
/// Command line testing
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
DateTime dt = DateTime.Now;
//args = new string[] { "hello" };
//args = new string[] { "testcases", "--loc", LocalProj, "--srcmlPath", SrcmlLoc };
args = new string[] { "summary", "--loc", LocalProj, "--srcmlPath", SrcmlLoc, "--outputLoc", outputLoc };
var options = new Options();
string invokedVerb = null;
object invokedVerbOptions = null;
if (!CommandLine.Parser.Default.ParseArguments(args, options,
(verb, verbOptions) =>
{
invokedVerb = verb;
invokedVerbOptions = verbOptions;
}))
{
Environment.Exit(CommandLine.Parser.DefaultExitCodeFail);
}
if (invokedVerb == "callgraph")
{
var callGraphOp = (CallgraphOptions)invokedVerbOptions;
var generator = new InvokeCallGraphGenerator(callGraphOp.LocationsPath, callGraphOp.SrcMLPath);
generator.run();
}
else if (invokedVerb == "testcases")
{
var testCaseOp = (TestCaseDetectOptions)invokedVerbOptions;
var detector = new TestCaseDetector.TestCaseDetector(testCaseOp.LocationsPath, testCaseOp.SrcMLPath);
detector.AnalyzeTestCases();
Console.WriteLine("print testcases");
foreach (var testCaseId in detector.AllTestCases)
{
Console.WriteLine(testCaseId.NamespaceName + " " + testCaseId.ClassName + " " + testCaseId.MethodName);
}
}
else if (invokedVerb == "summary")
{
var SummaryOp = (SummarizeTestOptions)invokedVerbOptions;
string execution = ConfigurationManager.AppSettings["Execution"];
//steps should be run as indicated by the numbers below
if (execution.Contains("CLONE") || execution.Contains("DETECT"))
{
ProjectCloner projectCloner = new ProjectCloner(SrcmlLoc);
//1:clone repos clones a list of repos into the folder C:\grouped. Repos are grouped per ecosystem
//a CSV file called groupedProjectsList.csv is then created in the specified cloneprojectsfolder (check App config)
//projectCloner.cloneRepos();
//projectCloner.cloneMainGHRepos();
//projectCloner.appendProjectPathsToGHTorrentCSV();
//projectCloner.detectTestCasesFromGHMainProjects();
//projectCloner.updateProjectCreatedAtDateForTestCases();
//projectCloner.generateFinalMainlineGHProjectsCSV();
//==OBSOLETE==projectCloner.importCommitsCSV();
//projectCloner.importForksFromCSV();//these are detected using JAVA. See ANdroid Popularity project
//projectCloner.InsertTop10ForksWith5MoreCommits30DaysOld();
//==OBSLOTE==USING JAVA here.==projectCloner.cloneGHProjectsFromDB();
//projectCloner.UpdatePathsForClonedProjects();
//projectCloner.UpdateTotalCommitsPerProject();
//projectCloner.detectTestCasesFromFinalProjects();
//2: detect test cases reads the groupedProjectsList.csv file and for each project in their it exracts details of test cases, and UUTs (classes and methods)
//this emthod then generates a two CSV files in the cloneProjects Folder. One is called testsAndUUTs_allprojects.csv, the other is classesAndMethods_allprojects.csv
//projectCloner.detectTestCasesDB();
}
DataAnalyzer dataAnalyzer = new DataAnalyzer();
if (execution.Contains("EXTRACTCLONES"))
{
//3: extract clones reads all ecosystem projects and extract clone fragments. It reads from the groupedProjects CSV file saved in the "clonedProjectsFolder"
//for each ecosstem in the groupedPrectsList.CSV it uses the clone detection tool Simian to generate clone pairs from all projects within the ecosystem
//to generate the cross-project clones we create one parent folder where we put all of an ecosystem's projects as sub-folders
//dataAnalyzer.extractClonesFromDB();
//update project comit details===OBSOLETE already done when extracting projects. see projectCloner.updateProjectCreatedAtDateForTestCases();
//dataAnalyzer.createProjectCommitDetails();
//generate clones pairs for defect prediction
//dataAnalyzer.ExtractClonesStandalone();
}
if (execution.Contains("UPDATEUUTPROJECTS"))
{
//4. for each test case generated in step 2 (in the file testsAndUUTs_allprojects.csv), update it by indicating projects where it is present, missing, and targets for propagation
//dataAnalyzer.updateUUTsWithProjectListsDB();
//update the UUT projects from CSV into Database
//dataAnalyzer.InsertTestCaseUUTPairsFromCSV();
//SINCE MANY DULCATES EXIST from teh genrated project lists CSV, generate one CSV with unique records only
//dataAnalyzer.GenerateUniqueTestCaseUUTPairsFromCSV();
}
if (execution.Contains("STUDYREPORTS"))
{
//5. Generate study reports
//these include: (1)project differences in commits i.e. for source projects of missing test cases and target projects
//(2) pairs of source UUTs for missing test cases and target UUTs
//dataAnalyzer.copyClonesToParentFolder();==OBSOLETE since when cloning projects we already group them by ecosystem
//DataAnalyzer.TestParseXML();
//5.1. Test case presence
//dataAnalyzer.generateTestCasePresence();
//5.2 Project differences between source and target projects for missing test cases
//These are mainly differences in number of commits and days since last commit.
//dataAnalyzer.getProjectDifferences();
//5.3 Test case UUT Target Pairs
//THis shows, for each missing test case, the source UUT and the possible target UUT matched from the clone pairs
//dataAnalyzer.createTestTargetUUTPairsWithMethodNames();
//5.4 Get unique test UUT pairs for files only so that we can get edit scripts at file level
//dataAnalyzer.createTestUUTPairsForEditScriptGeneration();
//5.5 NOw append editscripts generated to the large file with method pairs
//dataAnalyzer.appendEditScriptToLargeUUTPairs();
}
if (execution.Contains("CLEANDATA"))
{
//UUTPairDataCleaner.CleanData();
UUTPairDataCleaner.createTokenCountFiles();
}
//dataAnalyzer.CountEcoSystems();
//dataAnalyzer.CreateMappingOfMissingTestCases();
//TestPropagator testPropagator = new TestPropagator(LocalProj, targetProject, SrcmlLoc);
//testPropagator.propagate();
//var summary = new SummaryGenerator(SummaryOp.LocationsPath, SummaryOp.SrcMLPath);
//Console.WriteLine("This is summary");
//summary.AnalyzeSummary();
//summary.GenerateSummary(SummaryOp.OutputLoc);
//Console.WriteLine("Done!!!!!! Thanks.");
}
else if (invokedVerb == "hello")
{
Console.WriteLine("Hello");
//string proPath = @"C:\Users\[email protected]\Documents\RunningTest\Input\ConsoleApplication1";
//string proPath = @"C:\Users\[email protected]\Documents\RunningTest\Input\SrcML\ABB.SrcML";
using (var project = new DataProject <CompleteWorkingSet>(LocalProj, LocalProj, SrcmlLoc))
{
project.Update();
NamespaceDefinition globalNamespace;
project.WorkingSet.TryObtainReadLock(5000, out globalNamespace);
try
{
// Step 1. Build the call graph
Console.WriteLine("{0,10:N0} files", project.Data.GetFiles().Count());
Console.WriteLine("{0,10:N0} namespaces", globalNamespace.GetDescendants <NamespaceDefinition>().Count());
Console.WriteLine("{0,10:N0} types", globalNamespace.GetDescendants <TypeDefinition>().Count());
Console.WriteLine("{0,10:N0} methods", globalNamespace.GetDescendants <MethodDefinition>().Count());
Console.ReadLine();
var methods = globalNamespace.GetDescendants <MethodDefinition>();
// Step 2. Testing
Console.WriteLine("====== test 1 ========= ");
foreach (MethodDefinition m in methods)
{
Console.WriteLine("Method Name : {0}", m.GetFullName());
}
}
finally
{
project.WorkingSet.ReleaseReadLock();
}
}
Console.ReadLine();
Console.WriteLine("print hello");
}
TimeSpan ts = DateTime.Now - dt;
Console.WriteLine(ts.ToString());
Console.ReadLine();
}
public void analyzeProjectTestCases(string projectLocation, HashSet <TestCaseID> projectTestCases, HashSet <TestCaseSummary> projectTestSummary)
{
Console.WriteLine($"Analysing project {Path.GetFileName(projectLocation)}");
using (var project = new DataProject <CompleteWorkingSet>(projectLocation, projectLocation, srcMLexeLocation))
{
project.Update();
NamespaceDefinition globalNamespace;
project.WorkingSet.TryObtainReadLock(5000, out globalNamespace);
try
{
// Step 1. Build the call graph
Console.WriteLine("====== project summary ========= ");
Console.WriteLine("{0,10:N0} files", project.Data.GetFiles().Count());
Console.WriteLine("{0,10:N0} namespaces/packages", globalNamespace.GetDescendants <NamespaceDefinition>().Count());
Console.WriteLine("{0,10:N0} types", globalNamespace.GetDescendants <TypeDefinition>().Count());
Console.WriteLine("{0,10:N0} methods", globalNamespace.GetDescendants <MethodDefinition>().Count());
//Console.Read();
var methods = globalNamespace.GetDescendants <MethodDefinition>();
////print test cases
//StreamWriter wt = File.AppendText(@"C:\testpropagation\clones\testCases.csv");
//wt.WriteLine($"nameSpaceName;className;methodName");
//wt.Flush();
//foreach(TestCaseID id in projectTestCases)
//{
// wt.WriteLine($"{id.NamespaceName};{id.ClassName};{id.MethodName}");
// wt.Flush();
//}
//wt.Close();
////print methods
//StreamWriter w = File.AppendText(@"C:\testpropagation\clones\budMethods.csv");
//w.WriteLine($"nameSpaceName;className;methodName");
//w.Flush();
int i = 0;
// Step 2. Testing
Console.WriteLine("\n====== analysing methods and identifying UUTs ========= ");
foreach (MethodDefinition method in methods)
{
//colect basic ID information
var declaringClass = method.GetAncestors <TypeDefinition>().FirstOrDefault();
var className = "";
if (declaringClass != null)
{
className = declaringClass.Name;
}
var nameSpaceName = Utilities.GetNamespaceByMethod(method);
//w.WriteLine($"{nameSpaceName};{className};{method.Name}");
//w.Flush();
//continue;
if (Utilities.IsTestCase(method, projectTestCases))
{
//Console.WriteLine("Method Name : {0}", method.GetFullName());
SwumSummary swumSummary = new SwumSummary(method);
swumSummary.BasicSummary();
TestCaseAnalyzer analyzer = new TestCaseAnalyzer(method);
//analyzer.GetTestingObject();
string desc = swumSummary.Describe();
//writetext.WriteLine(method.Name + " , " + desc);
//Console.WriteLine(nameSpaceName + "," + className + "," + method.Name + "Swum Description : " + desc);
TestCaseSummary tcSummary = new TestCaseSummary(desc, analyzer.ListAssertInfo, method);
tcSummary.NameSpaceName = nameSpaceName;
tcSummary.ClassName = className;
tcSummary.MethodName = method.Name;
projectTestSummary.Add(tcSummary);
Dictionary <Statement, List <Statement> > focalToAssert = Utilities.GetFocalToAssert(analyzer.ListAssertInfo);
if (focalToAssert != null && focalToAssert.Count > 0)
{
foreach (Statement statement in focalToAssert.Keys)
{
Utilities.printMethodDetails(method, className, nameSpaceName, statement);
}
}
else
{
//print all methods in asserts
foreach (AssertSTInfo info in analyzer.ListAssertInfo)
{
Utilities.printMethodDetails(method, className, nameSpaceName, info.AssertStatment);
}
}
//Console.WriteLine(tcSummary.GetBodyDescriptions());
//var stmts = method.GetDescendants<Statement>();
//Console.WriteLine($"===Printing local methods tested by {method.GetFullName()}===");
//HashSet<MethodDefinition> local = analyzer.InvokedLocalMethods;
//foreach(MethodDefinition definition in local)
//{
// if (definition == null)
// {
// continue;
// }
// Console.WriteLine(definition.GetFullName());
//}
//Console.WriteLine($"===Printing external methods tested by {method.GetFullName()}===");
//HashSet<MethodDefinition> external = analyzer.InvokedExternalMethods;
//foreach (MethodDefinition definition in external)
//{
// if (definition == null)
// {
// continue;
// }
// Console.WriteLine(definition.GetFullName());
//}
//delete me
//using (StreamWriter sw = File.AppendText(@"D:\d.csv"))
//{
// var number = stmts.Count() + 2;
// sw.WriteLine(method.Name + "," + number);
// sw.Close();
//}
i++;
}
}
//w.Close();
}
finally
{
project.WorkingSet.ReleaseReadLock();
}
}
}
public static void analyzeProjectTestCases(string projectLocation, HashSet <TestCaseID> projectTestCases, DataController dc, string srcMLexeLocation, string testsAndUUTFile, string classesAndMethodsFile, string projectGitName, string parent, bool isFork)
{
Console.WriteLine($"Analysing project {projectGitName}");//Path.GetFileName(projectLocation)
using (var project = new DataProject <CompleteWorkingSet>(projectLocation, projectLocation, srcMLexeLocation))
{
project.Update();
NamespaceDefinition globalNamespace;
project.WorkingSet.TryObtainReadLock(5000, out globalNamespace);
//StreamWriter classesWriter = File.AppendText(classesAndMethodsFile);
//StreamWriter testsWriter = File.AppendText(testsAndUUTFile);
try
{
// Step 1. Build the call graph
Console.WriteLine("====== project summary ========= ");
Console.WriteLine("{0,10:N0} files", project.Data.GetFiles().Count());
Console.WriteLine("{0,10:N0} namespaces/packages", globalNamespace.GetDescendants <NamespaceDefinition>().Count());
Console.WriteLine("{0,10:N0} types", globalNamespace.GetDescendants <TypeDefinition>().Count());
var methods = globalNamespace.GetDescendants <MethodDefinition>();
int total = methods.Count();
Console.WriteLine("{0,10:N0} methods", total);
//Console.Read();
//=====THIS IS JUST TO PRINT OUT METHODS AND CLASSES
int i = 0;
//foreach(MethodDefinition method in methods)
//{
// var declaringClass = method.GetAncestors<TypeDefinition>().FirstOrDefault();
// var className = "";
// if (declaringClass != null)
// {
// className = declaringClass.Name;
// }
// var nameSpaceName = Utilities.GetNamespaceByMethod(method);
// printMethod(classesWriter, projectGitName, parent, isFork, nameSpaceName, className, method);
// Console.WriteLine($"{++i}/{total}");
//}
//return;
//==END PRINITNG
// Step 2. Testing
Console.WriteLine("\n====== analysing methods and identifying UUTs ========= ");
foreach (MethodDefinition method in methods)
{
try
{
//colect basic ID information
var declaringClass = method.GetAncestors <TypeDefinition>().FirstOrDefault();
var className = "";
if (declaringClass != null)
{
className = declaringClass.Name;
}
var nameSpaceName = Utilities.GetNamespaceByMethod(method);
dc.ProjectClassesInsert(projectGitName, parent, isFork, nameSpaceName, className, method.Name, method.ToString(), method.PrimaryLocation.SourceFileName, method.PrimaryLocation.StartingLineNumber, method.PrimaryLocation.EndingLineNumber, method.PrimaryLocation.StartingColumnNumber, method.PrimaryLocation.EndingColumnNumber);
//printMethod(dc, projectGitName, parent, isFork, nameSpaceName, className, method);
//printMethod(classesWriter, projectGitName, parent, isFork, nameSpaceName, className, method);
if (Utilities.IsTestCase(method, projectTestCases))
{
try
{
//Console.WriteLine("Test Method Name : {0}", method.GetFullName());
//SwumSummary swumSummary = new SwumSummary(method);
//swumSummary.BasicSummary();
TestCaseAnalyzer analyzer = new TestCaseAnalyzer(method);
//Console.WriteLine("Passed Analyzer for Test Method Name : {0}", method.GetFullName());
////analyzer.GetTestingObject();
//string desc = swumSummary.Describe();
////writetext.WriteLine(method.Name + " , " + desc);
////Console.WriteLine(nameSpaceName + "," + className + "," + method.Name + "Swum Description : " + desc);
//TestCaseSummary tcSummary = new TestCaseSummary(desc, analyzer.ListAssertInfo, method);
//tcSummary.NameSpaceName = nameSpaceName;
//tcSummary.ClassName = className;
//tcSummary.MethodName = method.Name;
//projectTestSummary.Add(tcSummary);
//======For the test case propagation, we are interested in reusing an entire test case, hence we must know all methods referenced in the test case. Thus we use theinvoked methods case
//Dictionary<Statement, List<Statement>> focalToAssert = Utilities.GetFocalToAssert(analyzer.ListAssertInfo);
//if (focalToAssert != null && focalToAssert.Count > 0)
//{
// foreach (Statement statement in focalToAssert.Keys)
// {
// printMethodDetails(testsWriter, projectGitName, parent, isFork, method, className, nameSpaceName, statement);
// }
//}
//else if (analyzer.ListAssertInfo != null && analyzer.ListAssertInfo.Count > 0)
//{
// //print all methods in asserts
// foreach (AssertSTInfo info in analyzer.ListAssertInfo)
// {
// printMethodDetails(testsWriter, projectGitName, parent, isFork, method, className, nameSpaceName, info.AssertStatment);
// }
//}
//else
//{
//all external methods referenced by the test method
HashSet <MethodDefinition> external = analyzer.InvokedExternalMethods;
foreach (MethodDefinition definition in external)
{
if (definition == null)
{
continue;
}
var mdCall = definition;
var decClass = mdCall.GetAncestors <TypeDefinition>().FirstOrDefault();
var mdClass = "";
if (decClass != null)
{
mdClass = decClass.Name;
}
var mdPackage = GetNamespaceByMethod(mdCall);
dc.TestUUTPairInsert(projectGitName, parent, isFork, nameSpaceName, className, method.Name, method.ToString(), method.PrimaryLocation.SourceFileName, method.PrimaryLocation.StartingLineNumber, method.PrimaryLocation.EndingLineNumber, method.PrimaryLocation.StartingColumnNumber, method.PrimaryLocation.EndingColumnNumber, mdPackage, mdClass, mdCall.Name, mdCall.ToString(), mdCall.PrimaryLocation.SourceFileName, mdCall.PrimaryLocation.StartingLineNumber, mdCall.PrimaryLocation.EndingLineNumber, mdCall.PrimaryLocation.StartingColumnNumber, mdCall.PrimaryLocation.EndingColumnNumber);
//printMethodDetails(dc, projectGitName, parent, isFork, method, className, nameSpaceName, definition);
//printMethodDetails(testsWriter, projectGitName, parent, isFork, method, className, nameSpaceName, definition);
}
//}
}catch (StackOverflowException ex)
{
Console.WriteLine(ex.Message);
}
}
}catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
i++;
Console.WriteLine($"{i}/{total}");
}
}
finally
{
//if (classesWriter != null)
//{
// classesWriter.Close();
//}
//if (testsWriter != null)
//{
// testsWriter.Close();
//}
project.WorkingSet.ReleaseReadLock();
}
}
}
public void AnalyzeSummary()
{
Console.WriteLine("Hello");
using (var project = new DataProject <CompleteWorkingSet>(LocalProj, LocalProj, SrcmlLoc))
{
project.Update();
NamespaceDefinition globalNamespace;
project.WorkingSet.TryObtainReadLock(5000, out globalNamespace);
try
{
// Step 1. Build the call graph
Console.WriteLine("{0,10:N0} files", project.Data.GetFiles().Count());
Console.WriteLine("{0,10:N0} namespaces", globalNamespace.GetDescendants <NamespaceDefinition>().Count());
Console.WriteLine("{0,10:N0} types", globalNamespace.GetDescendants <TypeDefinition>().Count());
Console.WriteLine("{0,10:N0} methods", globalNamespace.GetDescendants <MethodDefinition>().Count());
//Console.Read();
var methods = globalNamespace.GetDescendants <MethodDefinition>();
int i = 0;
// Step 2. Testing
Console.WriteLine("====== test 1 ========= ");
foreach (MethodDefinition method in methods)
{
Console.WriteLine("Method Name : {0}", method.GetFullName());
//colect basic ID information
var declaringClass = method.GetAncestors <TypeDefinition>().FirstOrDefault();
var className = "";
if (declaringClass != null)
{
className = declaringClass.Name;
}
var nameSpaceName = GetNamespaceByMethod(method);
//for testing
//if (className != "CPlusPlusCodeParserTests") {
// continue;
//}
//if (className != "BuiltInTypeFactoryTests") {
// continue;
//}
//if (i > 10)
//{
// continue;
//}
//if (method.Name != "CreateRequest_ETag")
//{
// continue;
//}
if (IsTestCase(method))
{
SwumSummary swumSummary = new SwumSummary(method);
swumSummary.BasicSummary();
TestCaseAnalyzer analyzer = new TestCaseAnalyzer(method);
//analyzer.GetTestingObject();
string desc = swumSummary.Describe();
//writetext.WriteLine(method.Name + " , " + desc);
Console.WriteLine(nameSpaceName + "," + className + "," + method.Name + "Swum Description : " + desc);
TestCaseSummary tcSummary = new TestCaseSummary(desc, analyzer.ListAssertInfo, method);
tcSummary.NameSpaceName = nameSpaceName;
tcSummary.ClassName = className;
tcSummary.MethodName = method.Name;
AllTestSummary.Add(tcSummary);
var stmts = method.GetDescendants <Statement>();
//delete me
//using (StreamWriter sw = File.AppendText(@"D:\d.csv"))
//{
// var number = stmts.Count() + 2;
// sw.WriteLine(method.Name + "," + number);
// sw.Close();
//}
i++;
}
}
}
finally
{
project.WorkingSet.ReleaseReadLock();
}
}
//Console.ReadLine();
//string dataDir = @"TESTNAIVE_1.0";
//using (var project = new DataProject<CompleteWorkingSet>(dataDir, this.LocalProj, this.SrcmlLoc)) {
// //Console.WriteLine("============================");
// //string unknownLogPath = Path.Combine(project.StoragePath, "unknown.log");
// //DateTime start = DateTime.Now, end;
// //Console.WriteLine("============================");
// //using (var unknownLog = new StreamWriter(unknownLogPath)) {
// // project.UnknownLog = unknownLog;
// // project.UpdateAsync().Wait();
// //}
// //end = DateTime.Now;
// project.Update();
// NamespaceDefinition globalNamespace;
// project.WorkingSet.TryObtainReadLock(5000, out globalNamespace);
// try {
// // Step 1. Build the call graph
// Console.WriteLine("{0,10:N0} files", project.Data.GetFiles().Count());
// Console.WriteLine("{0,10:N0} namespaces", globalNamespace.GetDescendants<NamespaceDefinition>().Count());
// Console.WriteLine("{0,10:N0} types", globalNamespace.GetDescendants<TypeDefinition>().Count());
// Console.WriteLine("{0,10:N0} methods", globalNamespace.GetDescendants<MethodDefinition>().Count());
// var methods = globalNamespace.GetDescendants<MethodDefinition>();
// int i = 0;
// StreamWriter writetext = new StreamWriter("write.csv");
// foreach (var method in methods) {
// //colect basic ID information
// var declaringClass = method.GetAncestors<TypeDefinition>().FirstOrDefault();
// var className = "";
// if (declaringClass != null) {
// className = declaringClass.Name;
// }
// var nameSpaceName = GetNamespaceByMethod(method);
// //for testing
// //if (className != "CPlusPlusCodeParserTests") {
// // continue;
// //}
// //if (className != "BuiltInTypeFactoryTests") {
// // continue;
// //}
// //if (className == "ProgamElementTests" || className == "CPlusPlusCodeParserTests") {
// // continue;
// //}
// //if (className != "CPlusPlusCodeParserTests") {
// // continue;
// //}
// //if (className != "SourceLocationTests") {
// // continue;
// //}
// //if (method.Name != "TestContains_DifferentLines") {
// // continue;
// //}
// //if (method.Name != "TestSiblingsBeforeSelf_MissingChild") {
// // continue;
// //}
// //if (i > 30) {
// // continue;
// //}
// if (IsTestCase(method)) {
// i++;
// SwumSummary swumSummary = new SwumSummary(method);
// swumSummary.BasicSummary();
// TestCaseAnalyzer analyzer = new TestCaseAnalyzer(method);
// //analyzer.GetTestingObject();
// string desc = swumSummary.Describe();
// //writetext.WriteLine(method.Name + " , " + desc);
// Console.WriteLine(nameSpaceName + "," + className + "," + method.Name + "Swum Description : " + desc);
// TestCaseSummary tcSummary = new TestCaseSummary(desc, analyzer.ListAssertInfo, method);
// tcSummary.NameSpaceName = nameSpaceName;
// tcSummary.ClassName = className;
// tcSummary.MethodName = method.Name;
// AllTestSummary.Add(tcSummary);
// i++;
// }
// }
// writetext.Close();
// //Console.WriteLine("total i :" + i);
// } finally {
// project.WorkingSet.ReleaseReadLock();
// }
//}
}