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 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 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 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 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()
{
}
}
}
";
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 MethodWithGenericParameters()
{
// Given
string code = @"
namespace Foo
{
class Green
{
public TValue Blue<TKey, TValue>(TKey key, TValue value, bool flag)
{
return value;
}
}
}
";
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(@"public TValue Blue<TKey, TValue>(TKey key, TValue value, bool flag)", GetMember(results, "Green", "Blue")["Syntax"]);
}
public async Task NamespacesDoNotContainNestedTypes()
{
// Given
const string code = @"
namespace Foo
{
class Blue
{
class Green
{
}
}
}
";
TestDocument document = GetDocument(code);
TestExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
IReadOnlyList <IDocument> results = await ExecuteAsync(document, context, module);
// Then
CollectionAssert.AreEquivalent(
new[] { "Blue" },
results.Single(x => x["Name"].Equals("Foo")).Get <IEnumerable <IDocument> >("MemberTypes").Select(x => x["Name"]));
}
public async Task ClassOperatorsContainsOperators()
{
// Given
const string code = @"
namespace Foo
{
public class Blue
{
public static Blue operator +(Blue a1, Blue a2)
{
return null;
}
public static explicit operator string(Blue b)
{
return null;
}
}
}
";
TestDocument document = GetDocument(code);
TestExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
IReadOnlyList <TestDocument> results = await ExecuteAsync(document, context, module);
// Then
CollectionAssert.AreEquivalent(
new[] { "op_Addition", "op_Explicit" },
GetResult(results, "Blue").Get <IReadOnlyList <IDocument> >("Operators").Select(x => x["Name"]));
}
public async Task ParameterParamsType()
{
// Given
const string code = @"
class Yellow
{
public void X(params int[] z)
{
}
}
";
TestDocument document = GetDocument(code);
TestExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
IReadOnlyList <TestDocument> results = await ExecuteAsync(document, context, module);
// Then
IDocument x = GetParameter(results, "Yellow", "X", "z");
IDocument y = (IDocument)x["Type"];
object z = y["Name"];
Assert.AreEqual("int[]", ((IDocument)GetParameter(results, "Yellow", "X", "z")["Type"])["Name"]);
}
public async Task ReturnTypeParamReferencesClass()
{
// Given
const string code = @"
namespace Foo
{
class Red<T>
{
public T Blue()
{
return default(T);
}
}
}
";
TestDocument document = GetDocument(code);
TestExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
IReadOnlyList <TestDocument> results = await ExecuteAsync(document, context, module);
// Then
Assert.AreEqual("Red", GetMember(results, "Red", "Blue").Get <IDocument>("ReturnType").Get <IDocument>("DeclaringType")["Name"]);
}
public async Task NestedNamespaceContainsDirectlyNestedNamespaces()
{
// Given
const string code = @"
namespace Foo
{
}
namespace Foo.Baz
{
}
namespace Foo.Bar
{
}
";
TestDocument document = GetDocument(code);
TestExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
IReadOnlyList <IDocument> results = await ExecuteAsync(document, context, module);
// Then
CollectionAssert.AreEquivalent(new[] { string.Empty, "Foo", "Baz", "Bar" }, results.Select(x => x["Name"]));
CollectionAssert.AreEquivalent(
new[] { "Baz", "Bar" },
results.Single(x => x["Name"].Equals("Foo")).Get <IEnumerable <IDocument> >("MemberNamespaces").Select(x => x["Name"]));
}
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 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 RestrictedToNamedTypesWithPredicate()
{
// Given
string code = @"
namespace Foo
{
public class Blue
{
public void Foo()
{
}
}
public interface Red
{
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp().WithNamedTypes(x => 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" }, results.Select(x => x["Name"]));
}
public void GetDocumentsForExternalInterfaces()
{
// Given
string code = @"
namespace Foo
{
class Red : IBlue, IFoo
{
}
interface IBlue
{
}
}
";
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", "Red", "IBlue" }, results.Select(x => x["Name"]));
CollectionAssert.AreEquivalent(new [] { "IBlue", "IFoo" }, GetResult(results, "Red").Get <IEnumerable <IDocument> >("AllInterfaces").Select(x => x["Name"]));
}
public void GetTypeParams()
{
// Given
string code = @"
namespace Foo
{
class Red<T>
{
}
interface IBlue<TKey, TValue>
{
}
}
";
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.AreEqual(new[] { "T" }, GetResult(results, "Red").Get <IEnumerable <IDocument> >("TypeParameters").Select(x => x["Name"]));
CollectionAssert.AreEqual(new[] { "TKey", "TValue" }, GetResult(results, "IBlue").Get <IEnumerable <IDocument> >("TypeParameters").Select(x => x["Name"]));
}
public void MembersReturnsAllMembersExceptConstructors()
{
// Given
string code = @"
namespace Foo
{
public class Blue
{
public Blue()
{
}
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
CollectionAssert.AreEquivalent(new[] { "Green", "Red", "_yellow", "Changed" },
GetResult(results, "Blue").Get <IReadOnlyList <IDocument> >("Members").Select(x => x["Name"]));
}
public void ReturnTypeParamReferencesClass()
{
// Given
string code = @"
namespace Foo
{
class Red<T>
{
public T Blue()
{
return default(T);
}
}
}
";
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("Red", GetMember(results, "Red", "Blue").Get <IDocument>("ReturnType").Get <IDocument>("DeclaringType")["Name"]);
stream.Dispose();
}
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 FullNameContainsContainingType()
{
// 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
CollectionAssert.AreEquivalent(new[] { string.Empty, "Foo", "Green", "Green.Blue", "Red", "Yellow", "Bar" }, results.Select(x => x["FullName"]));
}
public void ClassWithGenericTypeParametersAndBaseAndConstraints()
{
// Given
string code = @"
namespace Foo
{
class Green<out TKey, TValue> : Blue,
IFoo
where TValue : class
{
}
class 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 class Green<out TKey, TValue> : Blue, IFoo where TValue : class", GetResult(results, "Green")["Syntax"]);
}
public void ExplicitClassAccessibility()
{
// Given
string code = @"
namespace Foo
{
public 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(@"public class Green", GetResult(results, "Green")["Syntax"]);
stream.Dispose();
}
public void WritePathIsCorrect()
{
// Given
string code = @"
namespace Foo
{
class Red
{
void X()
{
}
}
}
class Yellow
{
void Y<T>()
{
}
}
";
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/Yellow/66F23CDD.html", "Foo/Red/A94FD382.html" },
results.Where(x => x["Kind"].Equals("Method")).Select(x => ((FilePath)x[Keys.WritePath]).FullPath));
}
public void ReturnTypeParamReferencesClass()
{
// Given
string code = @"
namespace Foo
{
class Red<T>
{
public T Blue()
{
return default(T);
}
}
}
";
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("Red", GetMember(results, "Red", "Blue").Get <IDocument>("ReturnType").Get <IDocument>("DeclaringType")["Name"]);
}
public void DisplayNameIsCorrect()
{
// Given
string code = @"
class Yellow
{
public void X()
{
}
void Y<T>(T a, int b)
{
}
void Z(bool a)
{
}
}
";
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("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"]);
}
public void ParameterParamsType()
{
// Given
string code = @"
class Yellow
{
public void X(params int[] z)
{
}
}
";
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
var x = GetParameter(results, "Yellow", "X", "z");
var y = (IDocument)x["Type"];
var z = y["Name"];
Assert.AreEqual("int[]", ((IDocument)GetParameter(results, "Yellow", "X", "z")["Type"])["Name"]);
}
public void ClassMemberExcludedByPredicate()
{
// Given
string code = @"
namespace Foo
{
public class Blue
{
void Green()
{
}
void Red()
{
}
}
}
";
IDocument document = GetDocument(code);
IExecutionContext context = GetContext();
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.Bool("IsResult")).Select(x => x["Name"]));
CollectionAssert.AreEquivalent(
new[] { "Red", "Green", "ToString", "Equals", "Equals", "ReferenceEquals", "GetHashCode", "GetType", "Finalize", "MemberwiseClone" },
GetResult(results, "Blue").Get <IReadOnlyList <IDocument> >("Members").Select(x => x["Name"]));
}
public void WrapsForLongClassSignature()
{
// Given
string code = @"
namespace Foo
{
class Green<TKey, TValue> : IReallyLongInterface, INameToForceWrapping, IFoo, IBar, IFooBar, ICircle, ISquare, IRectangle where TKey : class
{
}
}
";
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<TKey, TValue> : IReallyLongInterface, INameToForceWrapping, IFoo, IBar,
IFooBar, ICircle, ISquare, IRectangle
where TKey : class", GetResult(results, "Green")["Syntax"]);
stream.Dispose();
}
public void ExplicitProperty()
{
// Given
string code = @"
namespace Foo
{
class Green
{
public int Blue
{
get { return 1 ; }
}
}
}
";
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(@"public int Blue { get; }", GetMember(results, "Green", "Blue")["Syntax"]);
}
public void ClassComments()
{
// Given
string code = @"
namespace Foo
{
// asfd
[ Foo /* asdf */]
[Bar( /* asdf */ 5) ] // asdf
/* asfd */
class /* asfd */ Green // asdf
/* asdf */ : Blue // asfd
{
// asdf
}
class 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(@"[Foo]
[Bar(5)]
internal class Green : Blue", GetResult(results, "Green")["Syntax"]);
}
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 MethodAttributes()
{
// Given
string code = @"
namespace Foo
{
class Green
{
[ Foo]
[Bar ]
int 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(@"[Foo]
[Bar]
private int Blue()", GetMember(results, "Green", "Blue")["Syntax"]);
}
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 async Task DisplayNameIsCorrect()
{
// Given
const string code = @"
class Yellow
{
public void X()
{
}
void Y<T>(T a, int b)
{
}
void Z(bool a)
{
}
}
";
TestDocument document = GetDocument(code);
TestExecutionContext context = GetContext();
IModule module = new AnalyzeCSharp();
// When
IReadOnlyList <TestDocument> results = await ExecuteAsync(document, context, module);
// 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"]);
}
public void NestedNamespaceContainsDirectlyNestedNamespaces()
{
// Given
string code = @"
namespace Foo
{
}
namespace Foo.Baz
{
}
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[] { string.Empty, "Foo", "Baz", "Bar" }, results.Select(x => x["Name"]));
CollectionAssert.AreEquivalent(new[] { "Baz", "Bar" },
results.Single(x => x["Name"].Equals("Foo")).Get <IEnumerable <IDocument> >("MemberNamespaces").Select(x => x["Name"]));
}
public void NamespacesDoNotContainNestedTypes()
{
// Given
const string code = @"
namespace Foo
{
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[] { "Blue" },
results.Single(x => x["Name"].Equals("Foo")).Get <IEnumerable <IDocument> >("MemberTypes").Select(x => x["Name"]));
}
public void WrapsForLongMethodSignature()
{
// Given
string code = @"
namespace Foo
{
class Green
{
public TValue Blue<TKey, TValue>(TKey key, TValue value, bool flag, int something, int somethingElse, int anotherThing) where TKey : class
{
return value;
}
}
}
";
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(@"public TValue Blue<TKey, TValue>(TKey key, TValue value, bool flag, int something, int somethingElse, int anotherThing)
where TKey : class", GetMember(results, "Green", "Blue")["Syntax"]);
}
public void ClassOperatorsContainsOperators()
{
// Given
string code = @"
namespace Foo
{
public class Blue
{
public static Blue operator +(Blue a1, Blue a2)
{
return null;
}
public static explicit operator string(Blue b)
{
return null;
}
}
}
";
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[] { "op_Addition", "op_Explicit" },
GetResult(results, "Blue").Get <IReadOnlyList <IDocument> >("Operators").Select(x => x["Name"]));
}
public void WrapsForLongMethodSignature()
{
// Given
string code = @"
namespace Foo
{
class Green
{
public TValue Blue<TKey, TValue>(TKey key, TValue value, bool flag, int something, int somethingElse, int anotherThing) where TKey : class
{
return value;
}
}
}
";
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(@"public TValue Blue<TKey, TValue>(TKey key, TValue value, bool flag, int something, int somethingElse, int anotherThing)
where TKey : class", GetMember(results, "Green", "Blue")["Syntax"]);
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 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 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 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 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 MethodWithExceptionElement()
{
// Given
string code = @"
namespace Foo
{
class Green
{
/// <exception cref=""FooException"">Throws when null</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.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("<a href=\"/Foo/6412642C\">FooException</a>",
GetMember(results, "Green", "Go").Get<IReadOnlyList<KeyValuePair<string, string>>>("ExceptionHtml")[0].Key);
Assert.AreEqual("Throws when null",
GetMember(results, "Green", "Go").Get<IReadOnlyList<KeyValuePair<string, string>>>("ExceptionHtml")[0].Value);
stream.Dispose();
}
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 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 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 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 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 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();
}
