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(); }