public void ExceptionElementWithoutCref()
{
// Given
string code = @"
namespace Foo
{
class Green
{
/// <exception>Throws when null</exception>
void Go()
{
}
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.InputFolder.Returns(TestContext.CurrentContext.TestDirectory);
context.GetDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<KeyValuePair<string, object>>>())
.Returns(x => new TestDocument((IEnumerable<MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual(string.Empty,
GetMember(results, "Green", "Go").List<ReferenceComment>("Exceptions")[0].Name);
Assert.AreEqual("Throws when null",
GetMember(results, "Green", "Go").List<ReferenceComment>("Exceptions")[0].Html);
stream.Dispose();
}
public void ClassMembersContainsMethods()
{
// Given
string code = @"
namespace Foo
{
public class Blue
{
void Green()
{
}
void Red()
{
}
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.InputFolder.Returns(TestContext.CurrentContext.TestDirectory);
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<MetadataItem>>())
.Returns(x => new TestDocument((IEnumerable<MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new[] { "Green", "Red" },
GetResult(results, "Blue").Get<IReadOnlyList<IDocument>>("Members").Select(x => x["Name"]));
stream.Dispose();
}
public void TopLevelNamespaceContainsDirectlyNestedNamespaces()
{
// Given
string code = @"
namespace Foo
{
}
namespace Foo.Baz
{
}
namespace Bar
{
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.InputFolder.Returns(Environment.CurrentDirectory);
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<MetadataItem>>())
.Returns(x => new TestDocument((IEnumerable<MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new[] { string.Empty, "Foo", "Baz", "Bar" }, results.Select(x => x["Name"]));
CollectionAssert.AreEquivalent(new [] { "Foo", "Bar" },
results.Single(x => x["Name"].Equals(string.Empty)).Get<IEnumerable<IDocument>>("MemberNamespaces").Select(x => x["Name"]));
stream.Dispose();
}
public void ContainingTypeIsCorrect()
{
// Given
string code = @"
namespace Foo
{
public class Blue
{
void Green()
{
}
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.InputFolder.Returns(Environment.CurrentDirectory);
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<MetadataItem>>())
.Returns(x => new TestDocument((IEnumerable<MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("Blue", GetMember(results, "Blue", "Green").Get<IDocument>("ContainingType")["Name"]);
stream.Dispose();
}
public void SingleLineSummary()
{
// Given
string code = @"
namespace Foo
{
/// <summary>This is a summary.</summary>
class Green
{
}
/// <summary>This is another summary.</summary>
struct Red
{
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.InputFolder.Returns(Environment.CurrentDirectory);
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<MetadataItem>>())
.Returns(x => new TestDocument((IEnumerable<MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("This is a summary.", GetResult(results, "Green")["Summary"]);
Assert.AreEqual("This is another summary.", GetResult(results, "Red")["Summary"]);
stream.Dispose();
}
public void TopLevelNamespaceContainsDirectlyNestedNamespaces()
{
// Given
string code = @"
namespace Foo
{
}
namespace Foo.Baz
{
}
namespace Bar
{
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new[] { string.Empty, "Foo", "Baz", "Bar" }, results.Select(x => x["Name"]));
CollectionAssert.AreEquivalent(new [] { "Foo", "Bar" },
results.Single(x => x["Name"].Equals(string.Empty)).Get<IEnumerable<IDocument>>("MemberNamespaces").Select(x => x["Name"]));
}
public void MultiLineSummary()
{
// Given
string code = @"
namespace Foo
{
/// <summary>
/// This is a summary.
/// </summary>
class Green
{
}
/// <summary>
/// This is
/// another summary.
/// </summary>
struct Red
{
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("\n This is a summary.\n ", GetResult(results, "Green")["Summary"]);
Assert.AreEqual("\n This is\n another summary.\n ", GetResult(results, "Red")["Summary"]);
}
public void FullNameDoesNotContainFullHierarchy()
{
// Given
string code = @"
namespace Foo
{
}
namespace Foo.Bar
{
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<KeyValuePair<string, object>>>())
.Returns(x => new TestDocument((IEnumerable<KeyValuePair<string, object>>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new[] { string.Empty, "Foo", "Bar" }, results.Select(x => x["FullName"]));
stream.Dispose();
}
public void ImplicitMemberAccessibility()
{
// Given
string code = @"
namespace Foo
{
class Green
{
void Blue()
{
}
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.InputFolder.Returns(TestContext.CurrentContext.TestDirectory);
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<MetadataItem>>())
.Returns(x => new TestDocument((IEnumerable<MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual(@"private void Blue()", GetMember(results, "Green", "Blue")["Syntax"]);
stream.Dispose();
}
public void AbstractClass()
{
// Given
string code = @"
namespace Foo
{
abstract class Green
{
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.InputFolder.Returns(TestContext.CurrentContext.TestDirectory);
context.GetDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<KeyValuePair<string, object>>>())
.Returns(x => new TestDocument((IEnumerable<MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual(@"internal abstract class Green", GetResult(results, "Green")["Syntax"]);
stream.Dispose();
}
public void ClassMembersContainsMethods()
{
// Given
string code = @"
namespace Foo
{
public class Blue
{
void Green()
{
}
void Red()
{
}
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new[] { "Green", "Red" },
GetResult(results, "Blue").Get<IReadOnlyList<IDocument>>("Members").Select(x => x["Name"]));
}
public void AutoProperty()
{
// Given
string code = @"
namespace Foo
{
class Green
{
public int Blue { get; set; }
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<KeyValuePair<string, object>>>())
.Returns(x => new TestDocument((IEnumerable<KeyValuePair<string, object>>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual(@"public int Blue { get; set; }", GetMember(results, "Green", "Blue")["Syntax"]);
stream.Dispose();
}
public void BaseTypeIsCorrect()
{
// Given
string code = @"
namespace Foo
{
public class Red
{
}
public class Green : Red
{
}
struct Blue
{
}
interface Yellow
{
}
interface Purple : Yellow
{
}
enum Orange
{
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.InputFolder.Returns(TestContext.CurrentContext.TestDirectory);
context.GetDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<KeyValuePair<string, object>>>())
.Returns(x => new TestDocument((IEnumerable<MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("Object", results.Single(x => x["Name"].Equals("Red")).Get<IDocument>("BaseType")["Name"]);
Assert.AreEqual("Red", results.Single(x => x["Name"].Equals("Green")).Get<IDocument>("BaseType")["Name"]);
Assert.AreEqual("ValueType", results.Single(x => x["Name"].Equals("Blue")).Get<IDocument>("BaseType")["Name"]);
Assert.IsNull(results.Single(x => x["Name"].Equals("Yellow")).Get<IDocument>("BaseType"));
Assert.IsNull(results.Single(x => x["Name"].Equals("Purple")).Get<IDocument>("BaseType"));
Assert.AreEqual("Enum", results.Single(x => x["Name"].Equals("Orange")).Get<IDocument>("BaseType")["Name"]);
stream.Dispose();
}
public void ReturnsAllTypes()
{
// Given
string code = @"
namespace Foo
{
public class Blue
{
}
class Green
{
class Red
{
}
}
internal struct Yellow
{
}
enum Orange
{
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.InputFolder.Returns(TestContext.CurrentContext.TestDirectory);
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<MetadataItem>>())
.Returns(x => new TestDocument((IEnumerable<MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new[] { string.Empty, "Foo", "Blue", "Green", "Red", "Yellow", "Orange" }, results.Select(x => x["Name"]));
stream.Dispose();
}
public void ImplicitClassAccessibility()
{
// Given
string code = @"
namespace Foo
{
class Green
{
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual(@"internal class Green", GetResult(results, "Green")["Syntax"]);
}
public void DisplayNameContainsFullHierarchy()
{
// Given
string code = @"
namespace Foo
{
}
namespace Foo.Bar
{
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new[] { "global", "Foo", "Foo.Bar" }, results.Select(x => x["DisplayName"]));
}
public void DisplayNameIsCorrect()
{
// Given
string code = @"
class Yellow
{
public X()
{
}
void Y<T>(T a, int b)
{
}
Z(bool a)
{
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For <IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For <IExecutionContext>();
context.InputFolder.Returns(TestContext.CurrentContext.TestDirectory);
context.GetDocument(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <IEnumerable <KeyValuePair <string, object> > >())
.Returns(x => new TestDocument((IEnumerable <MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("X()", GetMember(results, "Yellow", "X")["DisplayName"]);
Assert.AreEqual("Y<T>(T, int)", GetMember(results, "Yellow", "Y")["DisplayName"]);
Assert.AreEqual("Z(bool)", GetMember(results, "Yellow", "Z")["DisplayName"]);
stream.Dispose();
}
public void AutoProperty()
{
// Given
const string code = @"
namespace Foo
{
class Green
{
public int Blue { get; set; }
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
GetMember(results, "Green", "Blue")["Syntax"].ShouldBe("public int Blue { get; set; }");
}
public void WritePathIsCorrect()
{
// Given
string code = @"
namespace Foo
{
namespace Bar
{
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new[] { "global/index.html", "Foo/index.html", "Foo.Bar/index.html" },
results.Where(x => x["Kind"].Equals("Namespace")).Select(x => ((FilePath)x[Keys.WritePath]).FullPath));
}
public void GetsTopLevelNamespaces()
{
// Given
string code = @"
namespace Foo
{
}
namespace Bar
{
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new [] { string.Empty, "Foo", "Bar" }, results.Select(x => x["Name"]));
}
public void SummaryWithUnknownSeeElement()
{
// Given
string code = @"
namespace Foo
{
/// <summary>Check <see cref=""Red""/> class</summary>
class Green
{
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("Check Red class", GetResult(results, "Green")["Summary"]);
}
public void NamespaceSummary()
{
// Given
string code = @"
/// <summary>This is a summary.</summary>
namespace Foo
{
class Green
{
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("This is a summary.", GetResult(results, "Foo")["Summary"]);
}
public void ExternalInclude()
{
// Given
string code = @"
namespace Foo
{
/// <include file=""Included.xml"" path=""//Test/*"" />
class Green
{
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("This is a included summary.", GetResult(results, "Green")["Summary"]);
}
public void GetsTopLevelNamespaces()
{
// Given
string code = @"
namespace Foo
{
}
namespace Bar
{
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new [] { string.Empty, "Foo", "Bar" }, results.Select(x => x["Name"]));
}
public void SpecificKindIsCorrect()
{
// Given
string code = @"
namespace Foo
{
public class Green
{
private class Blue
{
}
}
struct Red
{
}
}
namespace Foo.Bar
{
enum Yellow
{
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("Class", results.Single(x => x["Name"].Equals("Green"))["SpecificKind"]);
Assert.AreEqual("Class", results.Single(x => x["Name"].Equals("Blue"))["SpecificKind"]);
Assert.AreEqual("Struct", results.Single(x => x["Name"].Equals("Red"))["SpecificKind"]);
Assert.AreEqual("Enum", results.Single(x => x["Name"].Equals("Yellow"))["SpecificKind"]);
}
public void ContainingTypeIsCorrect()
{
// Given
string code = @"
namespace Foo
{
class Green
{
class Blue
{
}
}
struct Red
{
}
}
namespace Foo.Bar
{
enum Yellow
{
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.IsNull(results.Single(x => x["Name"].Equals("Green")).Get <IDocument>("ContainingType"));
Assert.AreEqual("Green", results.Single(x => x["Name"].Equals("Blue")).Get <IDocument>("ContainingType")["Name"]);
Assert.IsNull(results.Single(x => x["Name"].Equals("Red")).Get <IDocument>("ContainingType"));
Assert.IsNull(results.Single(x => x["Name"].Equals("Yellow")).Get <IDocument>("ContainingType"));
}
public void ClassMembersContainsMethods()
{
try
{
// Given
string code = @"
namespace Foo
{
public class Blue
{
void Green()
{
}
void Red()
{
}
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(
new[] { "Green", "Red", "ToString", "Equals", "Equals", "ReferenceEquals", "GetHashCode", "GetType", "Finalize", "MemberwiseClone" },
GetResult(results, "Blue").Get <IReadOnlyList <IDocument> >("Members").Select(x => x["Name"]));
}
catch (ReflectionTypeLoadException ex)
{
Console.WriteLine("Loader exceptions: " + Environment.NewLine + string.Join(Environment.NewLine, ex.LoaderExceptions.Select(x => x.Message)));
throw;
}
}
public void ClassWithGenericTypeParametersAndBaseAndConstraints()
{
// Given
string code = @"
namespace Foo
{
class Green<out TKey, TValue> : Blue,
IFoo
where TValue : class
{
}
class Blue
{
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For <IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For <IExecutionContext>();
context.InputFolder.Returns(TestContext.CurrentContext.TestDirectory);
context.GetDocument(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <IEnumerable <KeyValuePair <string, object> > >())
.Returns(x => new TestDocument((IEnumerable <MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual(@"internal class Green<out TKey, TValue> : Blue, IFoo where TValue : class", GetResult(results, "Green")["Syntax"]);
stream.Dispose();
}
public void ConstructorsIsPopulated()
{
// Given
string code = @"
namespace Foo
{
public class Blue
{
public Blue()
{
}
protected Blue(int x)
{
}
void Green()
{
}
int Red { get; }
string _yellow;
event ChangedEventHandler Changed;
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual(2, GetResult(results, "Blue").Get <IReadOnlyList <IDocument> >("Constructors").Count);
}
public void WrapsForLongClassSignature()
{
// Given
string code = @"
namespace Foo
{
class Green<TKey, TValue> : IReallyLongInterface, INameToForceWrapping, IFoo, IBar, IFooBar, ICircle, ISquare, IRectangle where TKey : class
{
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual(@"internal class Green<TKey, TValue> : IReallyLongInterface, INameToForceWrapping, IFoo, IBar,
IFooBar, ICircle, ISquare, IRectangle
where TKey : class", GetResult(results, "Green")["Syntax"]);
}
public void NestedNamespacesReferenceParents()
{
// Given
const string code = @"
namespace Foo
{
}
namespace Foo.Bar
{
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("Foo", results.Single(x => x["Name"].Equals("Bar")).Get <IDocument>("ContainingNamespace")["Name"]);
Assert.AreEqual(string.Empty, results.Single(x => x["Name"].Equals("Foo")).Get <IDocument>("ContainingNamespace")["Name"]);
}
public void Enum()
{
// Given
const string code = @"
namespace Foo
{
enum Green
{
Foo = 3,
Bar = 5
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
GetResult(results, "Green")["Syntax"].ShouldBe("internal enum Green");
}
public void EnumWithBase()
{
// Given
string code = @"
namespace Foo
{
enum Green : long
{
Foo = 3,
Bar = 5
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual(@"internal enum Green", GetResult(results, "Green")["Syntax"]);
}
public void WritePathIsCorrect()
{
// Given
string code = @"
namespace Foo
{
class Red
{
}
enum Green
{
}
namespace Bar
{
struct Blue
{
}
}
}
class Yellow
{
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new[] { "Foo/414E2165/index.html", "Foo.Bar/92C5B5C5/index.html", "global/439037DE/index.html", "Foo/53AB53EF/index.html" },
results.Where(x => x["Kind"].Equals("NamedType")).Select(x => ((FilePath)x[Keys.WritePath]).FullPath));
}
public void ClassMembersContainsMethods()
{
// Given
string code = @"
namespace Foo
{
public class Blue
{
void Green()
{
}
void Red()
{
}
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For <IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For <IExecutionContext>();
context.InputFolder.Returns(Environment.CurrentDirectory);
context.GetNewDocument(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <IEnumerable <MetadataItem> >())
.Returns(x => new TestDocument((IEnumerable <MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new[] { "Green", "Red" },
GetResult(results, "Blue").Get <IReadOnlyList <IDocument> >("Members").Select(x => x["Name"]));
stream.Dispose();
}
public void ClassMemberExcludedByPredicate()
{
// Given
string code = @"
namespace Foo
{
public class Blue
{
void Green()
{
}
void Red()
{
}
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<KeyValuePair<string, object>>>())
.Returns(x => new TestDocument((IEnumerable<KeyValuePair<string, object>>)x[2]));
IModule module = new AnalyzeCSharp().WhereSymbol(x => x.Name != "Green");
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new[] { string.Empty, "Foo", "Blue", "Red" }, results.Select(x => x["Name"]));
CollectionAssert.AreEquivalent(new[] { "Red" },
GetResult(results, "Blue").Get<IReadOnlyList<IDocument>>("Members").Where(x => x.Get<bool>("IsResult")).Select(x => x["Name"]));
CollectionAssert.AreEquivalent(new[] { "Red", "Green" },
GetResult(results, "Blue").Get<IReadOnlyList<IDocument>>("Members").Select(x => x["Name"]));
stream.Dispose();
}
public void NamespacesContainTypes()
{
// Given
const string code = @"
namespace Foo
{
class Red
{
}
}
namespace Foo.Bar
{
class Blue
{
}
class Green
{
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(
new[] { "Red" },
results.Single(x => x["Name"].Equals("Foo")).Get <IEnumerable <IDocument> >("MemberTypes").Select(x => x["Name"]));
CollectionAssert.AreEquivalent(
new[] { "Blue", "Green" },
results.Single(x => x["Name"].Equals("Bar")).Get <IEnumerable <IDocument> >("MemberTypes").Select(x => x["Name"]));
}
public void SummaryWithCElementAndInlineAndDeclaredCssClasses()
{
// Given
string code = @"
namespace Foo
{
/// <summary>
/// This is <c class=""code"">some code</c> in a summary.
/// </summary>
class Green
{
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp().WithCssClasses("code", "more-code");
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("\n This is <code class=\"code more-code\">some code</code> in a summary.\n ", GetResult(results, "Green")["Summary"]);
}
public void ImplicitMemberAccessibility()
{
// Given
const string code = @"
namespace Foo
{
class Green
{
void Blue()
{
}
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
GetMember(results, "Green", "Blue")["Syntax"].ShouldBe("private void Blue()");
}
public void ContainingTypeIsCorrect()
{
// Given
string code = @"
namespace Foo
{
public class Blue
{
void Green()
{
}
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("Blue", GetMember(results, "Blue", "Green").Get <IDocument>("ContainingType")["Name"]);
}
public void ReturnsAllTypes()
{
// Given
string code = @"
namespace Foo
{
public class Blue
{
}
class Green
{
class Red
{
}
}
internal struct Yellow
{
}
enum Orange
{
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new[] { string.Empty, "Foo", "Blue", "Green", "Red", "Yellow", "Orange" }, results.Select(x => x["Name"]));
}
public void SummaryWithMultipleCElements()
{
// Given
string code = @"
namespace Foo
{
/// <summary>
/// This is <c>some code</c> in <c>a</c> summary.
/// </summary>
class Green
{
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("\n This is <code>some code</code> in <code>a</code> summary.\n ", GetResult(results, "Green")["Summary"]);
}
public void NoDocsForImplicitSymbols()
{
// Given
string code = @"
namespace Foo
{
class Green
{
/// <summary>This is a summary.</summary>
Green() {}
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp()
.WhereSymbol(x => x is INamedTypeSymbol);
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.IsFalse(GetResult(results, "Green").Get <IReadOnlyList <IDocument> >("Constructors")[0].ContainsKey("Summary"));
}
public void MethodAttributes()
{
// Given
string code = @"
namespace Foo
{
class Green
{
[ Foo]
[Bar ]
int Blue()
{
}
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For <IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For <IExecutionContext>();
context.InputFolder.Returns(TestContext.CurrentContext.TestDirectory);
context.GetDocument(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <IEnumerable <KeyValuePair <string, object> > >())
.Returns(x => new TestDocument((IEnumerable <MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual(@"[Foo]
[Bar]
private int Blue()", GetMember(results, "Green", "Blue")["Syntax"]);
stream.Dispose();
}
public void OtherCommentsWithAttributes()
{
// Given
string code = @"
namespace Foo
{
/// <bar a='x'>Circle</bar>
/// <bar a='y' b='z'>Square</bar>
class Green
{
}
class Red
{
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual(1,
GetResult(results, "Green").List <OtherComment>("BarComments")[0].Attributes.Count);
Assert.AreEqual("x",
GetResult(results, "Green").List <OtherComment>("BarComments")[0].Attributes["a"]);
Assert.AreEqual(2,
GetResult(results, "Green").List <OtherComment>("BarComments")[1].Attributes.Count);
Assert.AreEqual("y",
GetResult(results, "Green").List <OtherComment>("BarComments")[1].Attributes["a"]);
Assert.AreEqual("z",
GetResult(results, "Green").List <OtherComment>("BarComments")[1].Attributes["b"]);
}
public void ContainingTypeIsCorrect()
{
// Given
string code = @"
namespace Foo
{
public class Blue
{
void Green()
{
}
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("Blue", GetMember(results, "Blue", "Green").Get<IDocument>("ContainingType")["Name"]);
}
public void ExplicitMemberAccessibility()
{
// Given
string code = @"
namespace Foo
{
class Green
{
internal void Blue()
{
}
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual(@"internal void Blue()", GetMember(results, "Green", "Blue")["Syntax"]);
}
public void ReturnsAllTypes()
{
// Given
string code = @"
namespace Foo
{
public class Blue
{
}
class Green
{
class Red
{
}
}
internal struct Yellow
{
}
enum Orange
{
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new[] { string.Empty, "Foo", "Blue", "Green", "Red", "Yellow", "Orange" }, results.Select(x => x["Name"]));
}
public void TypesExcludedByPredicate()
{
// Given
string code = @"
namespace Foo
{
public class Blue
{
}
class Green
{
class Red
{
}
}
internal struct Yellow
{
}
enum Orange
{
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp().WhereSymbol(x => x is INamedTypeSymbol && ((INamedTypeSymbol)x).TypeKind == TypeKind.Class);
// When
List <IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new[] { "Blue", "Green", "Red" }, results.Select(x => x["Name"]));
}
public void SummaryWithCElementAndInlineAndDeclaredCssClasses()
{
// Given
string code = @"
namespace Foo
{
/// <summary>
/// This is <c class=""code"">some code</c> in a summary.
/// </summary>
class Green
{
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.InputFolder.Returns(Environment.CurrentDirectory);
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<MetadataItem>>())
.Returns(x => new TestDocument((IEnumerable<MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp().WithCssClasses("code", "more-code");
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("\n This is <code class=\"code more-code\">some code</code> in a summary.\n ", GetResult(results, "Green")["Summary"]);
stream.Dispose();
}
public void OtherCommentsWithAttributes()
{
// Given
string code = @"
namespace Foo
{
/// <bar a='x'>Circle</bar>
/// <bar a='y' b='z'>Square</bar>
class Green
{
}
class Red
{
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.InputFolder.Returns(Environment.CurrentDirectory);
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<MetadataItem>>())
.Returns(x => new TestDocument((IEnumerable<MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual(1,
GetResult(results, "Green").List<OtherComment>("BarComments")[0].Attributes.Count);
Assert.AreEqual("x",
GetResult(results, "Green").List<OtherComment>("BarComments")[0].Attributes["a"]);
Assert.AreEqual(2,
GetResult(results, "Green").List<OtherComment>("BarComments")[1].Attributes.Count);
Assert.AreEqual("y",
GetResult(results, "Green").List<OtherComment>("BarComments")[1].Attributes["a"]);
Assert.AreEqual("z",
GetResult(results, "Green").List<OtherComment>("BarComments")[1].Attributes["b"]);
stream.Dispose();
}
public void WithDocsForImplicitSymbols()
{
// Given
string code = @"
namespace Foo
{
class Green
{
/// <summary>This is a summary.</summary>
Green() {}
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.InputFolder.Returns(Environment.CurrentDirectory);
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<MetadataItem>>())
.Returns(x => new TestDocument((IEnumerable<MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp()
.WhereSymbol(x => x is INamedTypeSymbol)
.WithDocsForImplicitSymbols();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("This is a summary.", GetResult(results, "Green").Get<IReadOnlyList<IDocument>>("Constructors")[0]["Summary"]);
stream.Dispose();
}
public void WritePathIsCorrect()
{
// Given
string code = @"
namespace Foo
{
namespace Bar
{
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<KeyValuePair<string, object>>>())
.Returns(x => new TestDocument((IEnumerable<KeyValuePair<string, object>>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new[] { "global\\index.html", "Foo\\index.html", "Foo.Bar\\index.html" },
results.Where(x => x["Kind"].Equals("Namespace")).Select(x => x["WritePath"]));
stream.Dispose();
}
public void NestedNamespacesReferenceParents()
{
// Given
string code = @"
namespace Foo
{
}
namespace Foo.Bar
{
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<KeyValuePair<string, object>>>())
.Returns(x => new TestDocument((IEnumerable<KeyValuePair<string, object>>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("Foo", results.Single(x => x["Name"].Equals("Bar")).Get<IDocument>("ContainingNamespace")["Name"]);
Assert.AreEqual(string.Empty, results.Single(x => x["Name"].Equals("Foo")).Get<IDocument>("ContainingNamespace")["Name"]);
stream.Dispose();
}
public void NamespacesDoNotContainNestedTypes()
{
// Given
string code = @"
namespace Foo
{
class Blue
{
class Green
{
}
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<KeyValuePair<string, object>>>())
.Returns(x => new TestDocument((IEnumerable<KeyValuePair<string, object>>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document },context).ToList(); // Make sure to materialize the result list
// Then
CollectionAssert.AreEquivalent(new[] { "Blue" },
results.Single(x => x["Name"].Equals("Foo")).Get<IEnumerable<IDocument>>("MemberTypes").Select(x => x["Name"]));
stream.Dispose();
}
public void MultipleExceptionElements()
{
// Given
string code = @"
namespace Foo
{
class Green
{
/// <exception cref=""FooException"">Throws when null</exception>
/// <exception cref=""BarException"">Throws for another reason</exception>
void Go()
{
}
}
class FooException : Exception
{
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.InputFolder.Returns(Environment.CurrentDirectory);
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<MetadataItem>>())
.Returns(x => new TestDocument((IEnumerable<MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual(2, GetMember(results, "Green", "Go").List<ReferenceComment>("Exceptions").Count);
Assert.AreEqual("<a href=\"/Foo/6412642C\">FooException</a>",
GetMember(results, "Green", "Go").List<ReferenceComment>("Exceptions")[0].Link);
Assert.AreEqual("FooException",
GetMember(results, "Green", "Go").List<ReferenceComment>("Exceptions")[0].Name);
Assert.AreEqual("Throws when null",
GetMember(results, "Green", "Go").List<ReferenceComment>("Exceptions")[0].Html);
Assert.AreEqual("BarException",
GetMember(results, "Green", "Go").List<ReferenceComment>("Exceptions")[1].Link);
Assert.AreEqual("BarException",
GetMember(results, "Green", "Go").List<ReferenceComment>("Exceptions")[1].Name);
Assert.AreEqual("Throws for another reason",
GetMember(results, "Green", "Go").List<ReferenceComment>("Exceptions")[1].Html);
stream.Dispose();
}
public void SummaryWithTableListElement()
{
// Given
string code = @"
namespace Foo
{
/// <summary>
/// This is a summary.
/// <list type=""table"">
/// <listheader>
/// <term>A</term>
/// <term>a</term>
/// </listheader>
/// <item>
/// <term>X</term>
/// <term>x</term>
/// </item>
/// <item>
/// <term>Y</term>
/// <term>y</term>
/// </item>
/// </list>
/// </summary>
class Green
{
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.InputFolder.Returns(Environment.CurrentDirectory);
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<MetadataItem>>())
.Returns(x => new TestDocument((IEnumerable<MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual(@"
This is a summary.
<table class=""table"">
<tr>
<th>A</th>
<th>a</th>
</tr>
<tr>
<td>X</td>
<td>x</td>
</tr>
<tr>
<td>Y</td>
<td>y</td>
</tr>
</table>
".Replace("\r\n", "\n").Replace(" ", " "), GetResult(results, "Green")["Summary"]);
stream.Dispose();
}
public void SummaryWithParaElementsAndNestedCElement()
{
// Given
string code = @"
namespace Foo
{
/// <summary>
/// <para>ABC</para>
/// <para>X<c>Y</c>Z</para>
/// </summary>
class Green
{
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.InputFolder.Returns(Environment.CurrentDirectory);
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<MetadataItem>>())
.Returns(x => new TestDocument((IEnumerable<MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("\n <p>ABC</p>\n <p>X<code>Y</code>Z</p>\n ", GetResult(results, "Green")["Summary"]);
stream.Dispose();
}
public void SummaryWithSeeElementToMethod()
{
// Given
string code = @"
namespace Foo
{
/// <summary>Check <see cref=""Red.Blue""/> method</summary>
class Green
{
}
class Red
{
void Blue()
{
}
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.InputFolder.Returns(Environment.CurrentDirectory);
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<MetadataItem>>())
.Returns(x => new TestDocument((IEnumerable<MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("Check <a href=\"/Foo/414E2165/00F22A50.html\">Blue()</a> method", GetResult(results, "Green")["Summary"]);
stream.Dispose();
}
public void RootSeealsoElement()
{
// Given
string code = @"
namespace Foo
{
/// <seealso cref=""Red""/>
class Green
{
}
class Red
{
}
}
";
MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(code));
IDocument document = Substitute.For<IDocument>();
document.GetStream().Returns(stream);
IExecutionContext context = Substitute.For<IExecutionContext>();
context.InputFolder.Returns(Environment.CurrentDirectory);
context.GetNewDocument(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<IEnumerable<MetadataItem>>())
.Returns(x => new TestDocument((IEnumerable<MetadataItem>)x[2]));
IModule module = new AnalyzeCSharp();
// When
List<IDocument> results = module.Execute(new[] { document }, context).ToList(); // Make sure to materialize the result list
// Then
Assert.AreEqual("<a href=\"/Foo/414E2165\">Red</a>", GetResult(results, "Green").Get<IReadOnlyList<string>>("SeeAlso")[0]);
stream.Dispose();
}
