public void TestRoundTripWithDefaultExtension(string sourceFileName, bool useCompression)
{
var sourceFilePath = Path.Combine(TestInputPath, sourceFileName);
var destFilePath = Path.Combine(TestInputPath, DefaultInputName);
LibSrcMLRunner runner = new LibSrcMLRunner();
runner.GenerateSrcMLFromFile(sourceFilePath, destFilePath + ".cpp", Language.CPlusPlus, new Collection <UInt32>()
{
LibSrcMLRunner.SrcMLOptions.SRCML_OPTION_POSITION
}, new Dictionary <string, Language>()
{
});
Assert.That(File.Exists(destFilePath + ".cpp0.xml"));
var fileUnit = SrcMLElement.Load(destFilePath + ".cpp0.xml");
var dataGenerator = new DataGenerator();
var nsd = dataGenerator.Parse(fileUnit.Element(SRC.Unit)) as NamespaceDefinition;
string outputFileName = Path.ChangeExtension(DefaultOutputName, useCompression ? XmlSerialization.DEFAULT_COMPRESSED_EXTENSION : XmlSerialization.DEFAULT_EXTENSION);
XmlSerialization.WriteElement(nsd, outputFileName);
var nsdFromFile = XmlSerialization.Load(outputFileName) as NamespaceDefinition;
DataAssert.StatementsAreEqual(nsd, nsdFromFile);
}
private void MenuItemLanguage_Click(object sender, RoutedEventArgs e)
{
try
{
var menuItem = (sender as MenuItem);
if (null != menuItem && menuItem.IsChecked)
{
menuItem.IsCheckable = false;
var otherMenuItems = from MenuItem item in MenuItemLanguage.Items.SourceCollection
where item != menuItem
select item;
foreach (var item in otherMenuItems)
{
item.IsChecked = false;
item.IsCheckable = true;
}
this._language = SrcMLElement.GetLanguageFromString(menuItem.Header.ToString());
sourceBox_TextChanged(sender, null);
}
}
catch (SrcMLException error)
{
PrintErrorInSrcmlBox(error.Message);
}
}
public void SingleFileTest()
{
generator.GenerateSrcMLFromFile("srcmltest\\foo.c", "srcml_xml\\singlefile.xml");
var unit = SrcMLElement.Load("srcml_xml\\singlefile.xml");
Assert.IsNotNull(unit);
Assert.AreEqual("srcmltest\\foo.c", unit.Attribute("filename").Value);
}
private void AddSourceFiles()
{
Console.WriteLine("Thread 2: adding file: " + @"TestFiles\small_json_reader.cpp.xml");
manager.AddSrcMLFile(SrcMLElement.Load(@"TestFiles\small_json_reader.cpp.xml"));
Console.WriteLine("Thread 2: adding file: " + @"TestFiles\function_def.cpp.xml");
manager.AddSrcMLFile(SrcMLElement.Load(@"TestFiles\function_def.cpp.xml"));
Console.WriteLine("Thread 2: adding file: " + @"TestFiles\function_def2.cpp");
manager.AddSourceFile(@"TestFiles\function_def2.cpp");
}
private static IEnumerable <ExtensionLanguagePair> ParseLanguageMap(string languageMapping)
{
foreach (var segment in languageMapping.Split(';'))
{
var parts = segment.Split('=');
var extension = parts[0];
Language language = SrcMLElement.GetLanguageFromString(parts[1]);
yield return(new ExtensionLanguagePair(extension, language));
}
}
public void TestGetLanguageForUnit_ValidLanguage()
{
string testXml = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
<unit xmlns=""http://www.sdml.info/srcML/src"" language=""C++"" filename=""test.cpp""><expr_stmt><expr></expr></expr_stmt>
</unit>";
XElement fileUnit = XElement.Parse(testXml);
Assert.AreEqual(Language.CPlusPlus, SrcMLElement.GetLanguageForUnit(fileUnit));
}
public void TestGetLanguageForUnit_InvalidLanguage()
{
string testXml = String.Format(@"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
<unit xmlns=""{0}"" language=""C+"" filename=""test.cpp""><expr_stmt><expr></expr></expr_stmt>
</unit>", SRC.NS);
XElement fileUnit = XElement.Parse(testXml);
Assert.Throws <SrcMLException>(() => SrcMLElement.GetLanguageForUnit(fileUnit));
}
public void TestGetLanguageForUnit_NoLanguage()
{
string testXml = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>
<unit xmlns=""http://www.sdml.info/srcML/src"" filename=""test.cpp""><expr_stmt><expr></expr></expr_stmt>
</unit>";
XElement fileUnit = XElement.Parse(testXml);
Assert.Throws <SrcMLException>(() => SrcMLElement.GetLanguageForUnit(fileUnit));
}
private void UpdateSupportedLanguages()
{
HashSet <Language> supportedLanguages = new HashSet <Language>(this.XmlGenerator.SupportedLanguages);
foreach (var item in this.MenuItemLanguage.Items)
{
var menuItem = item as MenuItem;
var language = SrcMLElement.GetLanguageFromString(menuItem.Header.ToString());
menuItem.IsEnabled = supportedLanguages.Contains(language);
}
}
public void TestGetLanguageForUnit_InvalidArgument()
{
string testXml = @"<function><type><name>int</name></type> <name>main</name><parameter_list>()</parameter_list> <block>{ }</block></function>";
XElement fileUnit = XElement.Parse(testXml);
Assert.Throws <ArgumentException>(() => SrcMLElement.GetLanguageForUnit(fileUnit));
fileUnit = null;
Assert.Throws <ArgumentNullException>(() => SrcMLElement.GetLanguageForUnit(fileUnit));
}
public void TestCSharpExpressionWithDefaultKeyword()
{
var generator = new SrcMLGenerator(TestConstants.SrcmlPath);
generator.GenerateSrcMLFromFile("external\\TestCSharpExpressionWithDefaultKeyword.cs", "external_xml\\TestCSharpExpressionWithDefaultKeyword.cs.xml");
var fileUnit = SrcMLElement.Load("external_xml\\TestCSharpExpressionWithDefaultKeyword.cs.xml");
var classB = fileUnit.Element(SRC.Class);
Assert.IsNotNull(classB);
Assert.AreEqual(2, classB.Descendants(SRC.Function).Count());
}
public void TestCSharpExpressionWithDefaultKeyword()
{
var generator = new SrcMLGenerator(Path.Combine(SrcMLHelper.GetSrcMLRootDirectory(), SrcMLHelper.srcMLExecutableLocation));
generator.GenerateSrcMLFromFile("external\\TestCSharpExpressionWithDefaultKeyword.cs", "external_xml\\TestCSharpExpressionWithDefaultKeyword.cs.xml");
var fileUnit = SrcMLElement.Load("external_xml\\TestCSharpExpressionWithDefaultKeyword.cs.xml");
var classB = fileUnit.Element(SRC.Class);
Assert.IsNotNull(classB);
Assert.AreEqual(2, classB.Descendants(SRC.Function).Count());
}
public void TestCacheRoundTrip()
{
manager.AddSrcMLFile(SrcMLElement.Load(@"TestFiles\json_reader.cpp.xml"));
int beforeCount = manager.GetSwumData().Count;
//string tempFile = Path.GetTempFileName();
string tempFile = "swum_cache.txt";
manager.PrintSwumCache(tempFile);
manager.ReadSwumCache(tempFile);
Assert.AreEqual(beforeCount, manager.GetSwumData().Count);
//TODO: add assertions that verify contents of SWUM
}
/// <summary>
/// Generates SWUMs for the method definitions within the given source file.
/// </summary>
/// <param name="sourcePath">The path to the source file.</param>
public void AddSourceFile(string sourcePath)
{
//Don't try to process files that SrcML can't handle
if (Archive != null && !Archive.IsValidFileExtension(sourcePath))
{
return;
}
var fileExt = Path.GetExtension(sourcePath);
if (fileExt == null || (Generator != null && !Generator.ExtensionMapping.ContainsKey(fileExt)))
{
return;
}
sourcePath = Path.GetFullPath(sourcePath);
XElement fileElement;
if (Archive != null)
{
fileElement = Archive.GetXElementForSourceFile(sourcePath);
if (fileElement == null)
{
LogEvents.SwumFileNotFoundInArchive(this, sourcePath);
}
}
else if (Generator != null)
{
string outFile = Path.GetTempFileName();
try {
Generator.GenerateSrcMLFromFile(sourcePath, outFile);
fileElement = SrcMLElement.Load(outFile);
if (fileElement == null)
{
LogEvents.SwumErrorGeneratingSrcML(this, sourcePath);
}
} finally {
File.Delete(outFile);
}
}
else
{
throw new InvalidOperationException("SwumManager - Archive and Generator are both null");
}
try {
if (fileElement != null)
{
AddSwumForMethodDefinitions(fileElement, sourcePath);
}
} catch (Exception e) {
LogEvents.SwumErrorCreatingSwum(this, sourcePath, e);
}
}
public void TestBooleanArgument()
{
var xml = @"<function><type><name>boolean</name></type> <name><name>Automobile</name><op:operator>::</op:operator><name>HasEmptyGasTank</name></name><parameter_list>(<param><decl><type><name>boolean</name></type> <name>gasTank</name></decl></param>)</parameter_list> <block>{
<return>return <expr><lit:literal type=""boolean"">false</lit:literal></expr>;</return>
}</block></function>";
var unit = fileUnitSetup.GetFileUnitForXmlSnippet(xml, "test.cpp");
var func = unit.Descendants(SRC.Function).First();
var mdn = new MethodDeclarationNode(SrcMLElement.GetNameForMethod(func).Value, ContextBuilder.BuildMethodContext(func));
builder.ApplyRules(mdn);
}
public void AddManyFiles()
{
for (int i = 0; i < 100; i++)
{
foreach (XElement methodElement in functions)
{
string funcName = SrcMLElement.GetNameForMethod(methodElement).Value;
MethodContext mc = ContextBuilder.BuildMethodContext(methodElement);
MethodDeclarationNode mdn = new MethodDeclarationNode(funcName, mc);
builder.ApplyRules(mdn);
}
}
}
public List <ProgramElement> Parse(string fileName)
{
var programElements = new List <ProgramElement>();
XElement sourceElements;
if (SrcMLService != null)
{
sourceElements = SrcMLService.GetXElementForSourceFile(fileName);
if (sourceElements != null)
{
programElements = Parse(fileName, sourceElements);
}
else
{
FileLogger.DefaultLogger.ErrorFormat("SrcMLCppParser: File not found in SrcMLService: {0}", fileName);
}
}
else if (Archive != null)
{
sourceElements = Archive.GetXElementForSourceFile(fileName);
if (sourceElements != null)
{
programElements = Parse(fileName, sourceElements);
}
else
{
LogEvents.ParserFileNotFoundInArchiveError(this, fileName);
}
}
else if (Generator != null)
{
string outFile = Path.GetTempFileName();
try {
//This is a C++ parser, so we'll convert the input file as C++ no matter what the file extension is
Generator.GenerateSrcMLFromFile(fileName, outFile, Language.CPlusPlus);
sourceElements = SrcMLElement.Load(outFile);
if (sourceElements != null)
{
programElements = Parse(fileName, sourceElements);
}
} finally {
File.Delete(outFile);
}
}
else
{
throw new InvalidOperationException("SrcMLCppParser - Archive and Generator are both null");
}
return(programElements);
}
public void TestCppStaticTypeModifier()
{
var generator = new SrcMLGenerator(TestConstants.SrcmlPath);
generator.GenerateSrcMLFromFile("external\\TestCppTypeModifiers.cpp", "external_xml\\TestCppStaticModifier.cpp.xml");
var fileUnit = SrcMLElement.Load("external_xml\\TestCppStaticModifier.cpp.xml");
var typeWithStatic = fileUnit.Descendants(SRC.Type).LastOrDefault();
Assert.IsNotNull(typeWithStatic);
var staticModifier = typeWithStatic.Elements(SRC.Specifier).FirstOrDefault();
Assert.IsNotNull(staticModifier);
Assert.AreEqual("static", staticModifier.Value);
}
public void TestCSharpUsingStatement()
{
var generator = new SrcMLGenerator(Path.Combine(SrcMLHelper.GetSrcMLRootDirectory(), SrcMLHelper.srcMLExecutableLocation));
generator.GenerateSrcMLFromFile("external\\TestCSharpUsingStatement.cs", "external_xml\\TestCSharpUsingStatement.cs.xml");
var fileUnit = SrcMLElement.Load("external_xml\\TestCSharpUsingStatement.cs.xml");
var usingBlock = fileUnit.Elements(SRC.Using_Stmt).FirstOrDefault();
Assert.IsNotNull(usingBlock);
Assert.AreEqual(1, usingBlock.Elements(SRC.Init).Count());
Assert.AreEqual(1, usingBlock.Elements(SRC.Block).Count());
}
public void TestCSharpUsingStatement()
{
var generator = new SrcMLGenerator(TestConstants.SrcmlPath);
generator.GenerateSrcMLFromFile("external\\TestCSharpUsingStatement.cs", "external_xml\\TestCSharpUsingStatement.cs.xml");
var fileUnit = SrcMLElement.Load("external_xml\\TestCSharpUsingStatement.cs.xml");
var usingBlock = fileUnit.Elements(SRC.Using).FirstOrDefault();
Assert.IsNotNull(usingBlock);
Assert.AreEqual(1, usingBlock.Elements(SRC.Declaration).Count());
Assert.AreEqual(1, usingBlock.Elements(SRC.Block).Count());
}
public void TestCppStaticTypeModifier()
{
var generator = new SrcMLGenerator(Path.Combine(SrcMLHelper.GetSrcMLRootDirectory(), SrcMLHelper.srcMLExecutableLocation));
generator.GenerateSrcMLFromFile("external\\TestCppTypeModifiers.cpp", "external_xml\\TestCppStaticModifier.cpp.xml");
var fileUnit = SrcMLElement.Load("external_xml\\TestCppStaticModifier.cpp.xml");
var typeWithStatic = fileUnit.Descendants(SRC.Declaration).LastOrDefault();
Assert.IsNotNull(typeWithStatic);
var staticModifier = typeWithStatic.Elements(SRC.Specifier).FirstOrDefault();
Assert.IsNotNull(staticModifier);
Assert.AreEqual("static", staticModifier.Value);
}
public void TestCSharpExpressionWithRemove()
{
var generator = new SrcMLGenerator(Path.Combine(SrcMLHelper.GetSrcMLRootDirectory(), SrcMLHelper.srcMLExecutableLocation));
generator.GenerateSrcMLFromFile("external\\TestCSharpExpressionWithRemove.cs", "external_xml\\TestCSharpExpressionWithRemove.cs.xml");
var fileUnit = SrcMLElement.Load("external_xml\\TestCSharpExpressionWithRemove.cs.xml");
var method = fileUnit.Descendants(SRC.Function).FirstOrDefault();
Assert.IsNotNull(method);
var methodBlock = method.Element(SRC.Block);
Assert.IsNotNull(methodBlock);
Assert.AreEqual(1, methodBlock.Elements(SRC.ExpressionStatement).Count());
}
public void TestCSharpExpressionWithRemove()
{
var generator = new SrcMLGenerator(TestConstants.SrcmlPath);
generator.GenerateSrcMLFromFile("external\\TestCSharpExpressionWithRemove.cs", "external_xml\\TestCSharpExpressionWithRemove.cs.xml");
var fileUnit = SrcMLElement.Load("external_xml\\TestCSharpExpressionWithRemove.cs.xml");
var method = fileUnit.Descendants(SRC.Function).FirstOrDefault();
Assert.IsNotNull(method);
var methodBlock = method.Element(SRC.Block);
Assert.IsNotNull(methodBlock);
Assert.AreEqual(1, methodBlock.Elements(SRC.ExpressionStatement).Count());
}
public void TestGetMethodSignature_InitializerList()
{
string testSrcML = @"<constructor><name><name>MyClass</name><op:operator>::</op:operator><name>MyClass</name></name><parameter_list>(<param><decl><type><name>int</name></type> <name>bar</name></decl></param>)</parameter_list> <member_list>: <call><name>_capacity</name><argument_list>(<argument><expr><lit:literal type=""number"">15</lit:literal></expr></argument>)</argument_list></call>, <call><name>_len</name><argument_list>(<argument><expr><lit:literal type=""number"">0</lit:literal></expr></argument>)</argument_list></call> </member_list><block>{
<if>if<condition>(<expr><name>bar</name> <op:operator>></op:operator> <call><name>GetNumber</name><argument_list>()</argument_list></call></expr>)</condition><then> <block>{
<return>return <expr><lit:literal type=""string"">""Hello, world!""</lit:literal></expr>;</return>
}</block></then> <else>else <block>{
<return>return <expr><lit:literal type=""string"">""Goodbye cruel world!""</lit:literal></expr>;</return>
}</block></else></if>
}</block></constructor>";
XElement xml = XElement.Parse(string.Format(srcMLFormat, testSrcML), LoadOptions.PreserveWhitespace);
string actual = SrcMLElement.GetMethodSignature(xml.Element(SRC.Constructor));
string expected = "MyClass::MyClass(int bar)";
Assert.AreEqual(expected, actual);
}
public void TestGetMethodSignature_Normal()
{
string testSrcML = @"<function><type><name>char</name><type:modifier>*</type:modifier></type> <name><name>MyClass</name><op:operator>::</op:operator><name>foo</name></name><parameter_list>(<param><decl><type><name>int</name></type> <name>bar</name></decl></param>)</parameter_list> <block>{
<if>if<condition>(<expr><name>bar</name> <op:operator>></op:operator> <call><name>GetNumber</name><argument_list>()</argument_list></call></expr>)</condition><then> <block>{
<return>return <expr><lit:literal type=""string"">""Hello, world!""</lit:literal></expr>;</return>
}</block></then> <else>else <block>{
<return>return <expr><lit:literal type=""string"">""Goodbye cruel world!""</lit:literal></expr>;</return>
}</block></else></if>
}</block></function>";
XElement xml = XElement.Parse(string.Format(srcMLFormat, testSrcML), LoadOptions.PreserveWhitespace);
string actual = SrcMLElement.GetMethodSignature(xml.Element(SRC.Function));
string expected = "char* MyClass::foo(int bar)";
Assert.AreEqual(expected, actual);
}
private IScope ParseFileUnit(XElement fileUnit)
{
var language = SrcMLElement.GetLanguageForUnit(fileUnit);
IScope scope = null;
ICodeParser parser;
if (parsers.TryGetValue(language, out parser))
{
try {
scope = parser.ParseFileUnit(fileUnit);
} catch (ParseException e) {
OnErrorRaised(new ErrorRaisedArgs(e));
}
}
return(scope);
}
public void TestRoundTrip(string sourceFileName, bool compressOutput)
{
var sourceFilePath = Path.Combine(TestInputPath, sourceFileName);
var srcMLGenerator = new SrcMLGenerator("SrcML");
var dataGenerator = new DataGenerator();
Assert.That(srcMLGenerator.Generate(sourceFilePath, DefaultInputName));
var fileUnit = SrcMLElement.Load(DefaultInputName);
var nsd = dataGenerator.Parse(fileUnit) as NamespaceDefinition;
XmlSerialization.WriteElement(nsd, DefaultOutputName, compressOutput);
var nsdFromFile = XmlSerialization.Load(DefaultOutputName, compressOutput) as NamespaceDefinition;
DataAssert.StatementsAreEqual(nsd, nsdFromFile);
}
/// <summary>
/// Creates a new srcML location object
/// </summary>
/// <param name="element">The srcML element that this location refers to</param>
/// <param name="fileUnit">The file unit that contains
/// <paramref name="element"/></param>
/// <param name="isReferenceLocation">true if this is a reference location; false
/// otherwise</param>
public SrcMLLocation(XElement element, XElement fileUnit, bool isReferenceLocation)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
if (fileUnit == null)
{
throw new ArgumentNullException("fileUnit");
}
this.SourceFileName = SrcMLElement.GetFileNameForUnit(fileUnit);
this.StartingLineNumber = element.GetSrcLineNumber();
this.StartingColumnNumber = element.GetSrcLinePosition();
this.XPath = element.GetXPath();
this.IsReference = isReferenceLocation;
SetEndingLocation(element);
}
public void TestRoundTripWithDefaultExtension(string sourceFileName, bool useCompression)
{
var sourceFilePath = Path.Combine(TestInputPath, sourceFileName);
var srcMLGenerator = new SrcMLGenerator("SrcML");
var dataGenerator = new DataGenerator();
Assert.That(srcMLGenerator.Generate(sourceFilePath, DefaultInputName));
var fileUnit = SrcMLElement.Load(DefaultInputName);
var nsd = dataGenerator.Parse(fileUnit) as NamespaceDefinition;
string outputFileName = Path.ChangeExtension(DefaultOutputName, useCompression ? XmlSerialization.DEFAULT_COMPRESSED_EXTENSION : XmlSerialization.DEFAULT_EXTENSION);
XmlSerialization.WriteElement(nsd, outputFileName);
var nsdFromFile = XmlSerialization.Load(outputFileName) as NamespaceDefinition;
DataAssert.StatementsAreEqual(nsd, nsdFromFile);
}
public void TestNounPhraseRule_KeyFileExists()
{
var xml = @"<function><type><name>bool</name></type> <name><name>COptionsPageConnectionSFTP</name><op:operator>::</op:operator><name>KeyFileExists</name></name><parameter_list>(<param><decl><type><name>const</name> <name>wxString</name><type:modifier>&</type:modifier></type> <name>keyFile</name></decl></param>)</parameter_list> <block>{
<return>return <expr><lit:literal type=""boolean"">true</lit:literal></expr>;</return>
}</block></function>";
var unit = fileUnitSetup.GetFileUnitForXmlSnippet(xml, "test.cpp");
var func = unit.Descendants(SRC.Function).First();
var mdn = new MethodDeclarationNode(SrcMLElement.GetNameForMethod(func).Value, ContextBuilder.BuildMethodContext(func));
builder.ApplyRules(mdn);
Assert.AreEqual(typeof(NounPhraseRule), mdn.SwumRuleUsed.GetType());
var expected = @"get(Verb) | Key(NounModifier) File(NounModifier) Exists(Noun)
++ [wx(NounModifier) String(NounIgnorable) - key(Unknown) File(Unknown)] ++ C(NounModifier) Options(NounModifier) Page(NounModifier) Connection(NounModifier) SFTP(Noun)" ;
Assert.AreEqual(expected, mdn.ToString());
}
