public void TheSignatureOfACodeFileShouldContain_TheLinesOfCodeCount()
{
var codefile = new CodeFile(CodeFileName, Code);
var linesOfCodeSignature = string.Format("(5)");
string signature = Signature.For(codefile);
signature.Should().Contain(linesOfCodeSignature);
}
public void ShouldFindInterestingCharacters()
{
var codeFile = new CodeFile(SampleCodeFile.CodeFileName, SampleCodeFile.Code);
codeFile.InterestingCharacters.Should().Contain.One(';');
codeFile.InterestingCharacters.Should().Contain.One('{');
codeFile.InterestingCharacters.Should().Contain.One('}');
}
public void read_and_write_with_a_link()
{
var project = CsProjFile.CreateAtSolutionDirectory("Foo", Guid.NewGuid().ToString());
var file = new CodeFile("..\\CommonAssemblyInfo.cs") {Link = "CommonAssemblyInfo.cs"};
project.Add(file);
project.Save();
var project2 = CsProjFile.LoadFrom(project.FileName);
project2.Find<CodeFile>("..\\CommonAssemblyInfo.cs")
.Link.ShouldEqual("CommonAssemblyInfo.cs");
}
public CodeModel(string source, string fileName)
{
_fileName = fileName;
_file = new CodeFile(this);
if (!string.IsNullOrEmpty(fileName))
{
switch (Path.GetFileName(fileName).ToLower())
{
case "stdlib.i":
case "stdlib.i&":
// Don't include this file if the user happens to have stdlib.i open right now.
break;
default:
AddIncludeFile(_fileName, "stdlib.i", false);
break;
}
}
_tracker = new Tracker(source);
_file.Parse(source, fileName);
}
public static Diagnostic IncompleteDeclaration(CodeFile file, TextSpan span)
{
return(new Diagnostic(file, span, DiagnosticLevel.CompilationError, DiagnosticPhase.Parsing, 3001, "Incomplete declaration"));
}
public static Diagnostic SelfOutsideMethod(CodeFile file, TextSpan span)
{
return(new Diagnostic(file, span, DiagnosticLevel.FatalCompilationError, DiagnosticPhase.Analysis, 6008,
"Can't use `self` outside of a method or constructor"));
}
public static Diagnostic VariableMayNotHaveBeenAssigned(CodeFile file, TextSpan span, Name name)
{
return(new Diagnostic(file, span, DiagnosticLevel.FatalCompilationError, DiagnosticPhase.Analysis, 6005,
$"Variable `{name}` may not have been assigned before use"));
}
public Scope(CodeFile file, int depth, ScopeHint hint)
{
_file = file;
_depth = depth;
_hint = ScopeHint.None;
}
public void ShouldReturnTheCompleteSignature()
{
var codefile = new CodeFile(CodeFileName, Code);
string signature = Signature.For(codefile);
signature.Should().Equal("code.cs (5): {;}");
}
private static void writeFileToFileSystem(CodeFile file, string text)
{
IoNic.WriteFile(text, file.FullPath); IoNic.WriteFile(text, file.FullPath);
Vs.Helper.Log.Add(LogEntry.Info("generated {0}", file.PathToProject));
}
public void ShouldGetTheLinesOfCode()
{
var codeFile = new CodeFile(SampleCodeFile.CodeFileName, SampleCodeFile.Code);
codeFile.LinesOfCode.Should().Equal(5);
}
public static Diagnostic CannotMoveBorrowedValue(CodeFile file, MoveExpressionSyntax expression)
{
return(new Diagnostic(file, expression.Span, DiagnosticLevel.FatalCompilationError, DiagnosticPhase.Analysis, 3009,
$"Cannot move borrowed value `{file.Code[expression.Expression.Span]}`"));
}
public static Diagnostic MustBeCallable(CodeFile file, ExpressionSyntax expression)
{
return(new Diagnostic(file, expression.Span, DiagnosticLevel.FatalCompilationError, DiagnosticPhase.Analysis, 3008,
$"Expression must be of callable type to be invoked `{file.Code[expression.Span]}`"));
}
public static Diagnostic CannotConvert(CodeFile file, ExpressionSyntax expression, DataType ofType, DataType toType)
{
return(new Diagnostic(file, expression.Span, DiagnosticLevel.FatalCompilationError, DiagnosticPhase.Analysis, 3007,
$"Cannot convert expression `{file.Code[expression.Span]}` of type `{ofType}` to type `{toType}`"));
}
public static Diagnostic CircularDefinition(CodeFile file, TextSpan span, Name typeDeclarationName)
{
return(new Diagnostic(file, span, DiagnosticLevel.FatalCompilationError, DiagnosticPhase.Analysis, 3006,
$"Declaration of type `{typeDeclarationName}` is part of a circular definition"));
}
public static Diagnostic MustBeABoolExpression(CodeFile file, TextSpan span)
{
return(new Diagnostic(file, span, DiagnosticLevel.FatalCompilationError, DiagnosticPhase.Analysis, 3005,
"Expression must be of type `bool`"));
}
private static void assertCodeFileIsCorrect(CodeFile codeFile, string expectedFullPath, string expectedContents)
{
Assert.That(codeFile.Id, Is.Not.EqualTo(Guid.Empty));
Assert.That(codeFile.Filename, Is.EqualTo(Path.GetFileName(expectedFullPath)));
Assert.That(codeFile.FullPath, Is.EqualTo(expectedFullPath));
Assert.That(codeFile.Content, Is.EqualTo(expectedContents));
Assert.That(codeFile.VcsRoot, Is.Not.Null);
var expectedRepoName = Path.GetDirectoryName(expectedFullPath).Split(Path.DirectorySeparatorChar).Last();
Assert.That(codeFile.VcsRoot.Name, Is.EqualTo(expectedRepoName));
}
public void ACodeFileShouldContainAName()
{
var codefile = new CodeFile("Name", SampleCodeFile.Code);
codefile.Name.Should().Equal("Name");
}
public override void Execute(Action <DaemonStageResult> committer)
{
var localIdentifierNames = new HashSet <string>(StringComparer.CurrentCultureIgnoreCase);
var highlightings = new List <HighlightingInfo>();
CodeFile.ProcessChildren <IIdentifier>(
node => {
localIdentifierNames.Add(node.Name);
localIdentifierNames.Add(RemovePrefixAndSuffix(node));
if (IsValidSpellCheckIdentifierNode(node))
{
highlightings.AddRange(FindHighlightings(node));
}
}
);
#if (RSHARP6 || RESHARP7)
var declarationsCache = CodeFile.GetPsiServices().CacheManager.GetDeclarationsCache(CodeFile.GetPsiModule(), true, true);
#else
var declarationsCache = CodeFile.GetPsiServices().Symbols;
#endif
CodeFile.ProcessChildren <ITreeNode>(
node => {
#if RSHARP6
if (node is JavaScriptGenericToken && (node as JavaScriptGenericToken).NodeType == JavaScriptTokenType.STRING_LITERAL)
{
highlightings.AddRange(FindStringHighlightings(node, localIdentifierNames, declarationsCache));
}
#else
if (node is IJavaScriptLiteralExpression && (node as IJavaScriptLiteralExpression).ConstantValueType == ConstantValueTypes.String)
{
highlightings.AddRange(FindStringHighlightings(node, localIdentifierNames, declarationsCache));
}
#endif
else if (node is IComment)
{
highlightings.AddRange(FindHighlightings(node as IComment, localIdentifierNames, declarationsCache));
}
}
);
committer(new DaemonStageResult(highlightings));
}
private void writeFile(CodeFile file)
{
if (shouldSkipFile(file))
return;
var text = CodeFormatter.Format(file.GetFileContents());
var writeFile = true;
if (File.Exists(file.FullPath))
{
var existingText = File.ReadAllText(file.FullPath);
if (text == existingText)
{
Vs.Helper.Log.Add(LogEntry.Info("no changes {0}", file.PathToProject));
writeFile = false;
}
else
{
checkOutFiles(file.FullPath);
}
}
if (!writeFile)
return;
ProjectFacade.writeFileToFileSystem(file, text);
if (Contains(file.PathToProject))
return;
Project.AddItem(file.VisualStudioItemTypeNode, file.PathToProject);
filesToAddToSourceControl.Add(file.FullPath);
}
/// <summary>
/// Processes the file.
/// </summary>
/// <param name="trackedMethods">The tracked methods.</param>
/// <param name="fileIds">The file ids of the class.</param>
/// <param name="filePath">The file path.</param>
/// <param name="methods">The methods.</param>
/// <returns>The <see cref="CodeFile"/>.</returns>
private static CodeFile ProcessFile(IDictionary <string, string> trackedMethods, HashSet <string> fileIds, string filePath, XElement[] methods)
{
var seqpntsOfFile = methods
.Elements("SequencePoints")
.Elements("SequencePoint")
.Where(seqpnt => (seqpnt.Attribute("fileid") != null &&
fileIds.Contains(seqpnt.Attribute("fileid").Value)) ||
(seqpnt.Attribute("fileid") == null && seqpnt.Parent.Parent.Element("FileRef") != null &&
fileIds.Contains(seqpnt.Parent.Parent.Element("FileRef").Attribute("uid").Value)))
.Select(seqpnt => new
{
LineNumberStart = int.Parse(seqpnt.Attribute("sl").Value, CultureInfo.InvariantCulture),
LineNumberEnd = seqpnt.Attribute("el") != null ? int.Parse(seqpnt.Attribute("el").Value, CultureInfo.InvariantCulture) : int.Parse(seqpnt.Attribute("sl").Value, CultureInfo.InvariantCulture),
Visits = seqpnt.Attribute("vc").Value.ParseLargeInteger(),
TrackedMethodRefs = seqpnt.Elements("TrackedMethodRefs")
.Elements("TrackedMethodRef")
.Select(t => new
{
Visits = t.Attribute("vc").Value.ParseLargeInteger(),
TrackedMethodId = t.Attribute("uid").Value
})
})
.OrderBy(seqpnt => seqpnt.LineNumberEnd)
.ToArray();
var branches = GetBranches(methods, fileIds);
var coverageByTrackedMethod = seqpntsOfFile
.SelectMany(s => s.TrackedMethodRefs)
.Select(t => t.TrackedMethodId)
.Distinct()
.ToDictionary(id => id, id => new CoverageByTrackedMethod {
Coverage = new int[] { }, LineVisitStatus = new LineVisitStatus[] { }
});
int[] coverage = new int[] { };
LineVisitStatus[] lineVisitStatus = new LineVisitStatus[] { };
if (seqpntsOfFile.Length > 0)
{
coverage = new int[seqpntsOfFile[seqpntsOfFile.LongLength - 1].LineNumberEnd + 1];
lineVisitStatus = new LineVisitStatus[seqpntsOfFile[seqpntsOfFile.LongLength - 1].LineNumberEnd + 1];
for (int i = 0; i < coverage.Length; i++)
{
coverage[i] = -1;
}
foreach (var trackedMethodCoverage in coverageByTrackedMethod)
{
trackedMethodCoverage.Value.Coverage = (int[])coverage.Clone();
trackedMethodCoverage.Value.LineVisitStatus = new LineVisitStatus[seqpntsOfFile[seqpntsOfFile.LongLength - 1].LineNumberEnd + 1];
}
foreach (var seqpnt in seqpntsOfFile)
{
for (int lineNumber = seqpnt.LineNumberStart; lineNumber <= seqpnt.LineNumberEnd; lineNumber++)
{
int visits = coverage[lineNumber] == -1 ? seqpnt.Visits : coverage[lineNumber] + seqpnt.Visits;
coverage[lineNumber] = visits;
if (lineVisitStatus[lineNumber] != LineVisitStatus.Covered)
{
bool partiallyCovered = false;
ICollection <Branch> branchesOfLine = null;
// Use 'LineNumberStart' instead of 'lineNumber' here. Branches have line number of first line of seqpnt
if (branches.TryGetValue(seqpnt.LineNumberStart, out branchesOfLine))
{
partiallyCovered = branchesOfLine.Any(b => b.BranchVisits == 0);
}
LineVisitStatus statusOfLine = visits > 0 ? (partiallyCovered ? LineVisitStatus.PartiallyCovered : LineVisitStatus.Covered) : LineVisitStatus.NotCovered;
lineVisitStatus[lineNumber] = (LineVisitStatus)Math.Max((int)lineVisitStatus[lineNumber], (int)statusOfLine);
}
if (visits > -1)
{
foreach (var trackedMethodCoverage in coverageByTrackedMethod)
{
if (trackedMethodCoverage.Value.Coverage[lineNumber] == -1)
{
trackedMethodCoverage.Value.Coverage[lineNumber] = 0;
trackedMethodCoverage.Value.LineVisitStatus[lineNumber] = LineVisitStatus.NotCovered;
}
}
}
foreach (var trackedMethod in seqpnt.TrackedMethodRefs)
{
var trackedMethodCoverage = coverageByTrackedMethod[trackedMethod.TrackedMethodId];
int trackeMethodVisits = trackedMethodCoverage.Coverage[lineNumber] == -1 ? trackedMethod.Visits : trackedMethodCoverage.Coverage[lineNumber] + trackedMethod.Visits;
LineVisitStatus statusOfLine = trackeMethodVisits > 0 ? (LineVisitStatus)Math.Min((int)LineVisitStatus.Covered, (int)lineVisitStatus[lineNumber]) : LineVisitStatus.NotCovered;
trackedMethodCoverage.Coverage[lineNumber] = trackeMethodVisits;
trackedMethodCoverage.LineVisitStatus[lineNumber] = statusOfLine;
}
}
}
}
var codeFile = new CodeFile(filePath, coverage, lineVisitStatus, branches);
foreach (var trackedMethodCoverage in coverageByTrackedMethod)
{
string name = null;
// Sometimes no corresponding MethodRef element exists
if (trackedMethods.TryGetValue(trackedMethodCoverage.Key, out name))
{
string shortName = name.Substring(name.Substring(0, name.IndexOf(':') + 1).LastIndexOf('.') + 1);
TestMethod testMethod = new TestMethod(name, shortName);
codeFile.AddCoverageByTestMethod(testMethod, trackedMethodCoverage.Value);
}
}
var methodsOfFile = methods
.Where(m => m.Element("FileRef") != null && fileIds.Contains(m.Element("FileRef").Attribute("uid").Value))
.ToArray();
SetMethodMetrics(codeFile, methodsOfFile);
SetCodeElements(codeFile, methodsOfFile);
return(codeFile);
}
public static string For(CodeFile codeFile)
{
var signature = CodeSignature(codeFile);
return string.Format("{0} ({1}): {2}", codeFile.Name, codeFile.LinesOfCode, signature);
}
private CodeFile ProcessIncludeFile(string fullPathName)
{
try
{
Trace.WriteLine(string.Concat("Processing include file: ", fullPathName));
var merger = new FileMerger();
merger.MergeFile(fullPathName, true);
var content = merger.MergedContent;
if (string.IsNullOrEmpty(content)) return null;
var file = new CodeFile(this);
file.Parse(content, fullPathName);
return file;
}
catch (Exception ex)
{
Trace.WriteLine(string.Format("Exception when merging file '{0}': {1}", fullPathName, ex));
return null;
}
}
/// <summary>
/// Extracts the metrics from the given <see cref="XElement">XElements</see>.
/// </summary>
/// <param name="codeFile">The code file.</param>
/// <param name="methodsOfFile">The methods of the file.</param>
private static void SetMethodMetrics(CodeFile codeFile, IEnumerable <XElement> methodsOfFile)
{
foreach (var methodGroup in methodsOfFile.GroupBy(m => m.Element("Name").Value))
{
var method = methodGroup.First();
// Exclude properties and lambda expressions
if (method.Attribute("skippedDueTo") != null ||
method.HasAttributeWithValue("isGetter", "true") ||
method.HasAttributeWithValue("isSetter", "true") ||
lambdaMethodNameRegex.IsMatch(methodGroup.Key))
{
continue;
}
var metrics = new List <Metric>()
{
new Metric(
ReportResources.CyclomaticComplexity,
ParserBase.CyclomaticComplexityUri,
MetricType.CodeQuality,
methodGroup.Max(m => int.Parse(m.Attribute("cyclomaticComplexity").Value, CultureInfo.InvariantCulture)),
MetricMergeOrder.LowerIsBetter),
new Metric(
ReportResources.SequenceCoverage,
ParserBase.CodeCoverageUri,
MetricType.CoveragePercentual,
methodGroup.Max(m => decimal.Parse(m.Attribute("sequenceCoverage").Value, CultureInfo.InvariantCulture))),
new Metric(
ReportResources.BranchCoverage,
ParserBase.CodeCoverageUri,
MetricType.CoveragePercentual,
methodGroup.Max(m => decimal.Parse(m.Attribute("branchCoverage").Value, CultureInfo.InvariantCulture)))
};
var npathComplexityAttributes = methodGroup.Select(m => m.Attribute("nPathComplexity")).Where(a => a != null).ToArray();
if (npathComplexityAttributes.Length > 0)
{
metrics.Insert(
1,
new Metric(
ReportResources.NPathComplexity,
ParserBase.NPathComplexityUri,
MetricType.CodeQuality,
npathComplexityAttributes
.Select(a => int.Parse(a.Value, CultureInfo.InvariantCulture))
.Max(a => a < 0 ? int.MaxValue : a),
MetricMergeOrder.LowerIsBetter));
}
var crapScoreAttributes = methodGroup.Select(m => m.Attribute("crapScore")).Where(a => a != null).ToArray();
if (crapScoreAttributes.Length > 0)
{
metrics.Add(new Metric(
ReportResources.CrapScore,
ParserBase.CrapScoreUri,
MetricType.CodeQuality,
crapScoreAttributes.Max(a => decimal.Parse(a.Value, CultureInfo.InvariantCulture)),
MetricMergeOrder.LowerIsBetter));
}
string fullName = ExtractMethodName(methodGroup.Key);
string shortName = methodRegex.Replace(fullName, m => string.Format(CultureInfo.InvariantCulture, "{0}({1})", m.Groups["MethodName"].Value, m.Groups["Arguments"].Value.Length > 0 ? "..." : string.Empty));
var methodMetric = new MethodMetric(fullName, shortName, metrics);
var seqpnt = method
.Elements("SequencePoints")
.Elements("SequencePoint")
.FirstOrDefault();
if (seqpnt != null)
{
methodMetric.Line = int.Parse(seqpnt.Attribute("sl").Value, CultureInfo.InvariantCulture);
}
codeFile.AddMethodMetric(methodMetric);
}
}
public static Diagnostic CantShadow(CodeFile file, TextSpan bindingSpan, TextSpan useSpan)
{
// TODO that use span needs converted to a line and column
return(new Diagnostic(file, bindingSpan, DiagnosticLevel.FatalCompilationError, DiagnosticPhase.Analysis, 6003,
$"Variable binding can't shadow. Shadowed binding used at {useSpan}"));
}
public static Diagnostic CantRebindAsMutableBinding(CodeFile file, TextSpan span)
{
return(new Diagnostic(file, span, DiagnosticLevel.FatalCompilationError, DiagnosticPhase.Analysis, 6002,
$"Mutable variable binding can't rebind previous variable binding"));
}
public FrmFileCoverage(CodeFile codeFile)
{
InitializeComponent();
_codeFile = codeFile;
}
public static Diagnostic VariableMayAlreadyBeAssigned(CodeFile file, TextSpan span, Name name)
{
return(new Diagnostic(file, span, DiagnosticLevel.FatalCompilationError, DiagnosticPhase.Analysis, 6004,
$"Variable `{name}` declared with `let` may already be assigned"));
}
public async Task <CodeFile> GetCodeFileAsync(string revisionId, string codeFileId)
{
var info = await GetBlobClient(revisionId, codeFileId).DownloadAsync();
return(await CodeFile.DeserializeAsync(info.Value.Content));
}
public static Diagnostic UseOfPossiblyMovedValue(CodeFile file, TextSpan span)
{
return(new Diagnostic(file, span, DiagnosticLevel.FatalCompilationError, DiagnosticPhase.Analysis, 6006,
"Use of possibly moved value."));
}
public UserDefinedType(string text, FileSpan fileSpan, ISyntaxEntity parent, CodeFile currentCodeFile)
: base(text, fileSpan, parent, currentCodeFile)
{
}
public static Diagnostic NoStringTypeDefined(CodeFile file)
{
return(new Diagnostic(file, new TextSpan(0, 0), DiagnosticLevel.FatalCompilationError, DiagnosticPhase.Analysis, 6009,
"Could not find a `String` type. A `String` type must be defined in the global namespace."));
}
public override async Task <CodeFile> GetCodeFileAsync(string originalName, Stream stream, bool runAnalysis)
{
return(await CodeFile.DeserializeAsync(stream));
}
public static Diagnostic UnexpectedToken(CodeFile file, TextSpan span)
{
return(new Diagnostic(file, span, DiagnosticLevel.CompilationError, DiagnosticPhase.Parsing, 3002, $"Unexpected token `{file.Code[span]}`"));
}
internal CodeFile CompileTest([PexAssumeUnderTest] CSharp target, string programText)
{
CodeFile result = target.Parse(programText, "");
return(result);
}
private CodeFile createCodeFileInDatabase(string codeFilePath, string fileContents)
{
var newCodeFile = new CodeFile
{
Filename = Path.GetFileName(codeFilePath),
FullPath = codeFilePath,
Content = fileContents
};
using(var session = _documentStore.OpenSession())
{
session.Store(newCodeFile);
session.SaveChanges();
}
return newCodeFile;
}
public static Diagnostic CantMove(CodeFile file, ExpressionSyntax expression)
{
return(new Diagnostic(file, expression.Span, DiagnosticLevel.FatalCompilationError, DiagnosticPhase.Analysis, 6004,
$"Can't move out of expression"));
}
public static Diagnostic CantAssignToImmutable(CodeFile file, TextSpan span)
{
return(new Diagnostic(file, span, DiagnosticLevel.FatalCompilationError, DiagnosticPhase.Analysis, 6005,
$"Can't assign to immutable variable"));
}
public ConversionException(CodeFile codeFile, Exception ex = null, string message = "")
: base(ex, message)
{
CodeFile = codeFile ?? CodeFile.Empty;
}
public void AddFile(CodeFile file)
{
Files.Add(file);
}
/// <summary>
/// Eexecute this code generator against a code file
/// </summary>
public CompilerResult Compile(CodeFile file) => Compile(new[] { file });
private bool shouldSkipFile(CodeFile file)
{
var response = Contains(file.PathToProject) && !file.OverwriteExistingFile;
if (response)
{
Vs.Helper.Log.Add(LogEntry.Trace(
"SKIPPED {0} already exists",
file.PathToProject));
}
return response;
}
public StructDefinition(string text, FileSpan fileSpan, ISyntaxEntity parent, CodeFile currentCodeFile) : base(text, fileSpan, parent, currentCodeFile)
{
}
private static string CodeSignature(CodeFile codeFile)
{
return string.Join(string.Empty, codeFile.InterestingCharacters);
}
protected Variable(string name, FileSpan location, ISyntaxEntity parent, CodeFile currentCodeFile)
: base(name, location, parent, currentCodeFile)
{
}
/// <summary>
/// Generates an <see cref="XmlElement" /> that represent a this resource.
/// </summary>
/// <param name="ownerDocument">The owner document to use to create the element.</param>
/// <param name="context">The context under which this method is executed, used to resolve the paths and load resources with.</param>
/// <returns>
/// An <see cref="XmlElement" /> that represent this resource.
/// </returns>
public virtual XmlNode ToXml(XmlDocument ownerDocument, SageContext context)
{
Contract.Requires<ArgumentNullException>(ownerDocument != null);
Contract.Requires<ArgumentNullException>(context != null);
XmlDocumentFragment result = ownerDocument.CreateDocumentFragment();
List<string> webPaths = new List<string>();
if (this.Unmerge)
{
if (codeFile == null)
{
codeFile = CodeFile.Create(
this.GetResolvedPhysicalPath(context),
this.GetResolvedWebPath(context));
}
foreach (string dependency in codeFile.Dependencies)
{
string webPath = context.Path.GetRelativeWebPath(dependency, true);
webPaths.Add(webPath);
}
}
else
{
webPaths.Add(this.GetResolvedWebPath(context));
}
if (this.Type == ResourceType.CSS)
{
foreach (string webPath in webPaths)
{
XmlElement link = ownerDocument.CreateElement("xhtml:link", XmlNamespaces.XHtmlNamespace);
link.SetAttribute("type", "text/css");
link.SetAttribute("rel", "stylesheet");
link.SetAttribute("href", webPath);
result.AppendChild(link);
}
}
else if (this.Type == ResourceType.JavaScript)
{
foreach (string webPath in webPaths)
{
XmlElement script = ownerDocument.CreateElement("xhtml:script", XmlNamespaces.XHtmlNamespace);
script.SetAttribute("type", "text/javascript");
script.SetAttribute("src", webPath);
result.AppendChild(script);
}
}
else if (this.Type == ResourceType.Icon)
{
XmlElement icon = ownerDocument.CreateElement("xhtml:link", XmlNamespaces.XHtmlNamespace);
icon.SetAttribute("rel", "icon");
icon.SetAttribute("href", webPaths[0]);
result.AppendChild(icon);
}
else
{
string documentPath = context.Path.Resolve(this.Path);
XmlDocument document = context.Resources.LoadXml(documentPath);
XmlElement importedElement = (XmlElement) ownerDocument.ImportNode(document.DocumentElement, true);
if (!string.IsNullOrWhiteSpace(this.Name))
{
var nameAttribute = ownerDocument.CreateAttribute("sage", "name", XmlNamespaces.SageNamespace);
nameAttribute.InnerText = this.Name;
importedElement.SetAttributeNode(nameAttribute);
}
result.AppendChild(importedElement);
}
return result;
}
static void Main(string[] args)
{
//var list1 = new List<HtmlElementTypes>();
//list1.AddRange(new [] { HtmlElementTypes.Html, HtmlElementTypes.A, HtmlElementTypes.Abbr, });
var pageSource = string.Empty;
var list = new List <string>
{
//// "file:///C:/1/bootstrap.html",
//"http://*****:*****@"\" + (300 + fileNumber)))
{
writer.WriteLine(@"// {0}", url);
entries.ToList().ForEach(elementDefinition =>
{
var codeEntryString = elementDefinition.GenerateCode(SupportedTargetLanguages.Java);
Console.WriteLine(codeEntryString);
writer.WriteLine(codeEntryString);
});
writer.Flush();
writer.Close();
}
/*
* // driver.findElement(By.xpath())
* // driver.findElement(By.className())
* // driver.findElement(By.cssSelector())
* // driver.findElement(By.id())
* // driver.findElement(By.linkText())
* // driver.findElement(By.name())
* // driver.findElement(By.partialLinkText())
* // driver.findElement(By.tagName())
*/
// 20160715
var onlyPageMembers = entries
.Where(entry => PageObjectParts.CodeOfMember == entry.CodeClass)
.Cast <IPageMemberCodeEntry>()
.ToList();
using (var tempWriter = new StreamWriter(folderForExportFiles + @"\" + (400 + fileNumber)))
{
// this worked
// entries.ToList().ForEach(eltDef => tempWriter.WriteLine("try {{ elementFound = \"0\"; elementDisplayed = \"0\"; allElementsNumber++; WebElement element = driver.findElement(By.{0}(\"{1}\")); foundElementsNumber++; elementFound = \"1\"; if (element.isDisplayed()) {{ displayedElementsNumber++; elementDisplayed = \"1\"; }} }} catch (Exception e) {{ System.out.println(\"failed: {1}\"); }} writeData(fileWriter, \"{0}\", \"{1}\", elementFound, elementDisplayed);",
// 20160715
// TODO: work only with code entries
// entries.ToList().ForEach(eltDef => tempWriter.WriteLine("testLocator(By.{0}(\"{1}\"), \"{0}\", \"{1}\");",
onlyPageMembers
.ForEach(eltDef => tempWriter.WriteLine("testLocator(By.{0}(\"{1}\"), \"{0}\", \"{1}\");",
// static void testLocator(org.openqa.selenium.By by, String locatorName, String locatorPath) {
eltDef.Locators.Any() ? eltDef.Locators.First(loc => loc.IsBestChoice).ElementSearchTypePreference.ToString() : "_",
eltDef.Locators.Any() ? eltDef.Locators.First(loc => loc.IsBestChoice).SearchString : "_"
));
tempWriter.Flush();
tempWriter.Close();
}
// 20160715
// exporter.WriteToFile(entries, folderForExportFiles + @"\" + (100 + ++fileNumber));
exporter.WriteToFile(onlyPageMembers, folderForExportFiles + @"\" + (100 + ++fileNumber));
var importedEntries = importer.LoadFromFile <HtmlElementTypes>(folderForExportFiles + @"\" + (100 + fileNumber));
exporter.WriteToFile(importedEntries, folderForExportFiles + @"\" + (200 + fileNumber));
});
Console.WriteLine("Completed!");
Console.ReadKey();
}
public void TheSignatureOfACodefileShouldContain_InterestingCharacters()
{
var codefile = new CodeFile(CodeFileName, Code);
string signature = Signature.For(codefile);
signature.Should().Contain("{;}");
}
/// <summary>
/// Extracts the metrics from the given <see cref="XElement">XElements</see>.
/// </summary>
/// <param name="codeFile">The code file.</param>
/// <param name="methodsOfFile">The methods of the file.</param>
private static void SetMethodMetrics(CodeFile codeFile, IEnumerable <XElement> methodsOfFile)
{
foreach (var method in methodsOfFile)
{
string fullName = method.Attribute("name").Value + method.Attribute("desc").Value;
if (fullName.StartsWith("lambda$"))
{
continue;
}
string shortName = methodRegex.Replace(fullName, m => string.Format(CultureInfo.InvariantCulture, "{0}({1})", m.Groups["MethodName"].Value, m.Groups["Arguments"].Value.Length > 0 ? "..." : string.Empty));
var metrics = new List <Metric>();
var lineRate = method.Elements("counter")
.Where(e => e.Attribute("type") != null && e.Attribute("type").Value == "LINE")
.FirstOrDefault();
if (lineRate != null)
{
decimal missed = decimal.Parse(lineRate.Attribute("missed").Value, CultureInfo.InvariantCulture);
decimal covered = decimal.Parse(lineRate.Attribute("covered").Value, CultureInfo.InvariantCulture);
decimal total = missed + covered;
metrics.Add(new Metric(
ReportResources.Coverage,
ParserBase.CodeCoverageUri,
MetricType.CoveragePercentual,
total == 0 ? (decimal?)null : Math.Round((100 * covered) / total, 2, MidpointRounding.AwayFromZero)));
}
else
{
// If no line rate available, do not add branch coverage too
continue;
}
var branchRate = method.Elements("counter")
.Where(e => e.Attribute("type") != null && e.Attribute("type").Value == "BRANCH")
.FirstOrDefault();
if (branchRate != null)
{
decimal missed = decimal.Parse(branchRate.Attribute("missed").Value, CultureInfo.InvariantCulture);
decimal covered = decimal.Parse(branchRate.Attribute("covered").Value, CultureInfo.InvariantCulture);
decimal total = missed + covered;
metrics.Add(new Metric(
ReportResources.BranchCoverage,
ParserBase.CodeCoverageUri,
MetricType.CoveragePercentual,
total == 0 ? (decimal?)null : Math.Round((100 * covered) / total, 2, MidpointRounding.AwayFromZero)));
}
else
{
// If no branch coverage is available, add default to avoid empty columns
metrics.Add(new Metric(
ReportResources.BranchCoverage,
ParserBase.CodeCoverageUri,
MetricType.CoveragePercentual,
null));
}
var methodMetric = new MethodMetric(fullName, shortName, metrics);
methodMetric.Line = method.Attribute("line") != null?int.Parse(method.Attribute("line").Value, CultureInfo.InvariantCulture) : default(int?);
codeFile.AddMethodMetric(methodMetric);
}
}
public void TheSignatureOfACodefileShouldContain_TheNameOfTheFile()
{
var codefile = new CodeFile(CodeFileName, Code);
string signature = Signature.For(codefile);
signature.Should().Contain("{;}");
}
private void GetCachedNestedIncludeFiles(CodeFile file)
{
foreach (var incl in file.IncludeFiles)
{
AddIncludeFile(incl.SourceFileName, incl.FileName, incl.SearchFileDir);
}
}
