public void when_visiting_root_then_visits_all_delegates()
{
var calledMethod = this.GetType().GetMethod("Called", BindingFlags.Instance | BindingFlags.NonPublic);
var delegates = new VisitorDelegates();
foreach (var prop in typeof(VisitorDelegates).GetProperties())
{
var actionTypeParam = prop.PropertyType.GetGenericArguments()[0];
var expression = Expression.Lambda(
prop.PropertyType,
Expression.Call(Expression.Constant(this), calledMethod, Expression.Constant(prop)),
Expression.Parameter(actionTypeParam));
prop.SetValue(delegates, expression.Compile());
}
var members = DocReader.Read(typeof(Sample).Assembly);
members.Accept(new DelegateVisitor(delegates));
foreach (var prop in typeof(VisitorDelegates).GetProperties())
{
if (prop == Reflect <VisitorDelegates> .GetProperty(x => x.VisitUnknownMember))
{
continue;
}
Assert.True(calls.GetOrAdd(prop, 0) > 0, string.Format("Delegate on {0} was not called.", prop.Name));
}
}
public void when_reading_unknown_member_then_marks_as_unknown()
{
var xml = Path.GetTempFileName();
File.WriteAllText(xml, @"<doc>
<members>
<member name='!:Error'>
<summary>
blah
</summary>
</member>
</members>
</doc>");
var member = DocReader.Read(xml).Elements.OfType <UnknownMember>().FirstOrDefault();
Assert.NotNull(member);
Assert.Equal(MemberKinds.Unknown, member.Kind);
var visited = default(UnknownMember);
var delegates = new VisitorDelegates {
VisitUnknownMember = x => visited = x
};
member.Accept(new DelegateVisitor(delegates));
Assert.Same(member, visited);
}
public void when_reading_assembly_then_can_access_id_map()
{
var members = DocReader.Read(assembly);
Assert.NotNull(members.IdMap);
Assert.NotNull(members.IdMap.FindId(typeof(IProvider)));
}
public void when_reading_assemblies_from_different_platforms_then_succeeds()
{
var metro = new FileInfo(@"..\..\..\Demo\DemoMetro\bin\DemoMetro.dll").FullName;
var sl = new FileInfo(@"..\..\..\Demo\DemoSilverlight\bin\DemoSilverlight.dll").FullName;
var wp = new FileInfo(@"..\..\..\Demo\DemoPhone\bin\DemoPhone.dll").FullName;
var clr = new FileInfo(@"..\..\..\Demo\DemoProject\bin\DemoProject.dll").FullName;
var countMetro = new CountingVisitor("NuDoq-metro");
var countSl = new CountingVisitor("NuDoq-sl");
var countWp = new CountingVisitor("NuDoq-wp");
var countClr = new CountingVisitor("NuDoq-net");
DocReader.Read(Assembly.LoadFrom(metro)).Accept(countMetro);
DocReader.Read(Assembly.LoadFrom(sl)).Accept(countSl);
DocReader.Read(Assembly.LoadFrom(wp)).Accept(countWp);
DocReader.Read(Assembly.LoadFrom(clr)).Accept(countClr);
Assert.Equal(countMetro.TypeCount, countClr.TypeCount);
Assert.Equal(countSl.TypeCount, countClr.TypeCount);
Assert.Equal(countWp.TypeCount, countClr.TypeCount);
Assert.Equal(countMetro.ElementCount, countClr.ElementCount);
Assert.Equal(countSl.ElementCount, countClr.ElementCount);
Assert.Equal(countWp.ElementCount, countClr.ElementCount);
Assert.Equal(countMetro.ContainerCount, countClr.ContainerCount);
Assert.Equal(countSl.ContainerCount, countClr.ContainerCount);
Assert.Equal(countWp.ContainerCount, countClr.ContainerCount);
}
public void when_reading_assembly_then_can_access_source_document()
{
var xmlFile = Path.ChangeExtension(assembly.Location, ".xml");
var members = DocReader.Read(assembly);
Assert.NotNull(members.Xml);
Assert.Equal(xmlFile, new Uri(members.Xml.BaseUri).LocalPath);
}
public void when_reading_assembly_then_succeeds()
{
var clr = new FileInfo(@"DemoProject.dll").FullName;
var countClr = new CountingVisitor("NuDoq-net");
DocReader.Read(Assembly.LoadFrom(clr)).Accept(countClr);
}
public void when_reading_list_then_can_access_type_header_and_items()
{
var list = DocReader.Read(assembly).Traverse().OfType <List>().Single();
Assert.Equal(ListType.Table, list.Type);
Assert.NotNull(list.Header);
Assert.Equal(1, list.Items.Count());
}
public void when_reading_xml_then_to_string_renders_xml_location()
{
var assembly = typeof(IProvider).Assembly;
var xmlFile = Path.ChangeExtension(assembly.Location, ".xml");
var members = DocReader.Read(xmlFile);
Assert.Contains(xmlFile, members.ToString());
}
public void when_reading_member_then_to_string_contains_member_id()
{
var assembly = typeof(IProvider).Assembly;
var xmlFile = Path.ChangeExtension(assembly.Location, ".xml");
var member = DocReader.Read(xmlFile).Elements.OfType <Member>().First();
Assert.Contains(member.Id, member.ToString());
}
public void when_xml_not_found_alongside_assembly_then_throws()
{
var clr = new FileInfo(@"..\..\..\Demo\DemoProject\bin\DemoProject.dll").FullName;
var temp = Path.GetTempFileName();
File.Copy(clr, temp, true);
Assert.Throws <FileNotFoundException>(() => DocReader.Read(Assembly.LoadFrom(temp)).Traverse().Count());
}
public void when_reading_out_element_then_can_read_parameter_doc()
{
var member = DocReader.Read(Assembly.GetExecutingAssembly());
var method = member.Elements.OfType <Method>()
.FirstOrDefault(m => m.Info?.DeclaringType == typeof(CustomXml) && m.Info?.Name == nameof(CustomXml.Out));
Assert.NotNull(method);
Assert.Equal("p1", method.Elements.OfType <Param>().First().Name);
Assert.Equal("out", method.Elements.OfType <Param>().First().Elements.OfType <Text>().First().Content);
}
public void when_reading_extension_method_then_provides_typed_member()
{
var typed = DocReader.Read(assembly)
.Elements
.OfType <ExtensionMethod>()
.FirstOrDefault();
Assert.NotNull(typed);
Assert.NotNull(typed.Info);
}
public void when_documenting_generic_method_on_generic_type_then_sets_info()
{
var map = new MemberIdMap();
map.Add(typeof(SampleGeneric <,>));
var typeId = map.FindId(typeof(SampleGeneric <,>).GetMethods()[0]);
var member = DocReader.Read(assembly).Elements.OfType <Method>().Where(c => c.Id == typeId).FirstOrDefault();
Assert.NotNull(member);
Assert.NotNull(member.Info);
}
public void when_reading_indexer_property_then_succeeds()
{
var member = DocReader.Read(Assembly.GetExecutingAssembly(), new ReaderOptions {
KeepNewLinesInText = true
});
var method = member.Elements.OfType <Property>()
.FirstOrDefault(m => m.Info?.DeclaringType == typeof(CustomXml) && ((PropertyInfo)m.Info !).GetIndexParameters().Length > 0);
Assert.NotNull(method);
Assert.Equal("indexed", method.ToText());
}
public void when_parsing_property_then_reads_value_tag()
{
var map = new MemberIdMap();
map.Add(typeof(Sample));
var typeId = map.FindId(typeof(Sample).GetProperties()[0]);
var member = DocReader.Read(assembly).Elements.OfType <Property>().Where(c => c.Id == typeId).Single();
var element = member.Elements.OfType <Value>().Single();
Assert.Equal("The id of this sample.", element.ToText());
}
public void when_parsing_empty_code_then_removes_empty_text()
{
var map = new MemberIdMap();
map.Add(typeof(IProvider));
var typeId = map.FindId(typeof(IProvider));
var member = DocReader.Read(assembly).Elements.OfType <Interface>().Where(c => c.Id == typeId).Single();
var element = member.Elements.OfType <Remarks>().Single().Elements.OfType <Code>().Single();
Assert.Equal(0, element.Content.Length);
}
public void when_reading_unknown_element_then_can_be_empty()
{
var member = DocReader.Read(Assembly.GetExecutingAssembly());
var method = member.Elements.OfType <Method>()
.FirstOrDefault(m => m.Info?.DeclaringType == typeof(CustomXml) && m.Info?.Name == nameof(CustomXml.Preliminary));
Assert.NotNull(method);
Assert.Equal("preliminary", method.Elements.OfType <UnknownElement>().First().Xml.Name.LocalName);
Assert.Empty(method.Elements.OfType <UnknownElement>().First().Elements);
Assert.Empty(method.Elements.OfType <UnknownElement>().First().Attributes);
}
public void when_reading_weird_indenting_then_preserves_text()
{
var member = DocReader.Read(Assembly.GetExecutingAssembly(), new ReaderOptions {
KeepNewLinesInText = true
});
var method = member.Elements.OfType <Method>()
.FirstOrDefault(m => m.Info?.DeclaringType == typeof(CustomXml) && m.Info?.Name == nameof(CustomXml.WeirdIndenting));
Assert.NotNull(method);
Assert.Equal(@"Begin
End", method.ToText());
}
public void when_reading_provider_then_reads_remarks()
{
var map = new MemberIdMap();
map.Add(assembly);
var id = map.FindId(typeof(Provider));
Assert.NotNull(id);
var member = DocReader.Read(typeof(Provider).Assembly).Elements.OfType <Member>().FirstOrDefault(x => x.Id == id);
Assert.NotNull(member);
var element = member.Elements.OfType <Remarks>().FirstOrDefault();
Assert.NotNull(element);
var children = element.Elements.ToList();
Assert.Equal(3, children.Count);
Assert.IsType <Text>(children[0]);
Assert.IsType <Example>(children[1]);
Assert.IsType <List>(children[2]);
Assert.Equal("Remarks.", ((Text)children[0]).Content);
Assert.Equal("Example with code:", ((Example)children[1]).Elements.OfType <Text>().First().Content);
Assert.Equal(@"var code = new Code();
var length = code.Length + 1;", ((Example)children[1]).Elements.OfType <Code>().First().Content);
Assert.Equal("inline code", ((Example)children[1]).Elements.OfType <Para>().First().Elements.OfType <C>().First().Content);
Assert.Equal("Term", ((List)children[2])
.Elements.OfType <ListHeader>().First()
.Elements.OfType <Term>().First().Elements.OfType <Text>().First().Content);
Assert.Equal("Description", ((List)children[2])
.Elements.OfType <ListHeader>().First()
.Elements.OfType <Description>().First().Elements.OfType <Text>().First().Content);
Assert.NotNull(((List)children[2]).Header.Term);
Assert.NotNull(((List)children[2]).Header.Description);
Assert.Equal("ItemTerm", ((List)children[2])
.Elements.OfType <Item>().First()
.Elements.OfType <Term>().First().Elements.OfType <Text>().First().Content);
Assert.NotNull(((List)children[2]).Items.First().Term);
Assert.NotNull(((List)children[2]).Items.First().Description);
Assert.Equal("ItemDescription", ((List)children[2])
.Elements.OfType <Item>().First()
.Elements.OfType <Description>().First().Elements.OfType <Text>().First().Content);
}
public void when_reading_element_then_can_access_xml_line_info()
{
var xmlFile = Path.ChangeExtension(assembly.Location, ".xml");
var member = DocReader.Read(xmlFile).Elements.SelectMany(x => x.Traverse()).OfType <Summary>().First();
var lineInfo = member as IXmlLineInfo;
Assert.NotNull(lineInfo);
Assert.True(lineInfo.HasLineInfo());
Assert.NotEqual(0, lineInfo.LineNumber);
Assert.NotEqual(0, lineInfo.LinePosition);
}
public void when_parsing_empty_summary_then_removes_empty_text()
{
var map = new MemberIdMap();
map.Add(typeof(Provider));
var typeId = map.FindId(typeof(Provider));
var member = DocReader.Read(assembly).Elements.OfType <Class>().Where(c => c.Id == typeId).Single();
var element = member.Elements.OfType <Summary>().Single();
Assert.Empty(element.ToText());
}
public void when_rendering_to_string_then_renders_tag_name_for_unknown_elements()
{
DocReader.Read(typeof(IProvider).Assembly)
.Elements
.SelectMany(x => x.Traverse())
.OfType <UnknownElement>()
.Select(x => new { Element = x, ToString = x.ToString() })
.ToList()
.ForEach(x => Assert.True(
x.ToString.Contains("<" + x.Element.Xml.Name.LocalName + ">"),
"Element " + x.Element.ToString() + " ToString() was expected to contain <" + x.Element.Xml.Name.LocalName + ">"));
}
public void when_rendering_to_string_then_renders_tag_name_for_known_elements()
{
DocReader.Read(typeof(IProvider).Assembly)
.Elements
.SelectMany(x => x.Traverse())
.Where(x => !(x is Member || x is UnknownElement))
.Select(x => new { Element = x, ToString = x.ToString() })
.ToList()
.ForEach(x => Assert.True(
x.ToString.StartsWith("<" + x.Element.GetType().Name.ToLowerInvariant() + ">"),
"Element " + x.Element.ToString() + " ToString() was expected to start with <" + x.Element.GetType().Name.ToLowerInvariant() + ">"));
}
public void when_visiting_xml_then_adds_members()
{
var member = DocReader.Read(Path.ChangeExtension(typeof(ProviderType).Assembly.Location, ".xml"));
var visitor = new XmlVisitor();
member.Accept(visitor);
Assert.Equal("doc", visitor.Xml.Root.Name);
Assert.Equal("members", visitor.Xml.Root.Elements().First().Name);
//WriteXml(visitor.Xml);
}
public void when_reading_document_then_visits_document()
{
var xmlFile = Path.ChangeExtension(assembly.Location, ".xml");
var members = DocReader.Read(xmlFile);
DocumentMembers docMembers = null;
members.Accept(new DelegateVisitor(new VisitorDelegates
{
VisitDocument = doc => docMembers = doc,
}));
Assert.NotNull(docMembers);
}
public void when_parsing_unknown_element_then_reads_inner_content()
{
var map = new MemberIdMap();
map.Add(typeof(IProvider));
var typeId = map.FindId(typeof(IProvider));
var member = DocReader.Read(assembly).Elements.OfType <TypeDeclaration>().Where(c => c.Id == typeId).Single();
var element = member.Elements.OfType <Summary>().Single();
Assert.True(element.Elements.OfType <UnknownElement>().Any());
Assert.True(element.Elements.OfType <UnknownElement>().Single().Elements.OfType <Text>().Any());
}
public void when_writing_xml_then_can_roundtrip()
{
var originalXml = XDocument.Load(Path.ChangeExtension(typeof(ProviderType).Assembly.Location, ".xml"));
var member = DocReader.Read(typeof(ProviderType).Assembly);
var visitor = new XmlVisitor();
member.Accept(visitor);
//WriteXml(originalXml.Normalize(), "C:\\Temp\\source.xml");
//WriteXml(visitor.Xml.Normalize(), "C:\\Temp\\target.xml");
//Assert.True(originalXml.NormalizedEquals(visitor.Xml));
}
public void when_visiting_xml_then_adds_source_assembly()
{
var member = DocReader.Read(typeof(ProviderType).Assembly);
var visitor = new XmlVisitor();
member.Accept(visitor);
Assert.Equal("doc", visitor.Xml.Root.Name);
Assert.Equal("assembly", visitor.Xml.Root.Elements().First().Name);
Assert.Equal(typeof(ProviderType).Assembly.GetName().Name, visitor.Xml.Root.Elements().First().Elements().First().Value);
//WriteXml(visitor.Xml);
}
public void when_rendering_c_then_renders_text()
{
var map = new MemberIdMap();
map.Add(typeof(SampleStruct));
var id = map.FindId(typeof(SampleStruct));
var member = DocReader.Read(typeof(SampleStruct).Assembly).Elements.OfType <Struct>().Single(x => x.Id == id);
var actual = member.Elements.OfType <Summary>().First().ToText();
var expected = "Sample struct.";
Assert.Equal(expected, actual);
}
public void when_rendering_see_then_renders_cref()
{
var map = new MemberIdMap();
map.Add(typeof(SampleExtensions));
var id = map.FindId(typeof(SampleExtensions));
var member = DocReader.Read(typeof(SampleExtensions).Assembly).Elements.OfType <Class>().Single(x => x.Id == id);
var actual = member.Elements.OfType <Summary>().First().ToText();
var expected = "Extension class for Demo.Sample.";
Assert.Equal(expected, actual);
}
