public void MatchCanReceiveNullResolver()
{
XmlMatch match = new ElementMatch("foo");
XmlReader reader = GetReader("<foo/>");
match.Matches(reader, null);
}
public override MatchData Match(Element element, string pathPart)
{
if (!Valid(element))
{
return(null);
}
return(ElementMatch <Container> .From(element, pathPart, refExpr));
}
public void ShouldMatchElementForRootToo()
{
XmlReader reader = GetReader("<root/>");
ElementMatch match = new ElementMatch("root", MatchMode.StartElement);
reader.MoveToContent();
Assert.IsTrue(match.Matches(reader, null));
}
public void MatchThrowsIfPrefixButNoResolver()
{
XmlMatch match = new ElementMatch("foo", "bar");
XmlReader reader = GetReader("<foo:bar xmlns:foo='xml-mvp'/>");
reader.MoveToContent();
match.Matches(reader, null);
}
public void ThrowsIfWildcardNameWithPrefixAndNoResolver()
{
XmlMatch match = new ElementMatch("x", "*");
XmlReader reader = GetReader("<x:foo xmlns:x='xml-mvp'><x:bar/></x:foo>");
reader.MoveToContent();
match.Matches(reader, null);
}
public void ShouldMatchElementForRootToo()
{
XmlReader reader = GetReader("<root/>");
ElementMatch match = new ElementMatch("root", MatchMode.StartElement);
reader.MoveToContent();
Assert.IsTrue(match.Matches(reader, null));
}
public void ShouldMatchStartElementCloseIfNoAttributes()
{
XmlReader reader = GetReader("<root></root>");
ElementMatch match = new ElementMatch("root", MatchMode.StartElementClosed);
reader.MoveToContent();
Assert.IsTrue(match.Matches(reader, null));
}
public void ShouldMatchStartElementCloseIfNoAttributes()
{
XmlReader reader = GetReader("<root></root>");
ElementMatch match = new ElementMatch("root", MatchMode.StartElementClosed);
reader.MoveToContent();
Assert.IsTrue(match.Matches(reader, null));
}
public void ShouldMatchElement()
{
XmlReader reader = GetReader("<root><foo></foo></root>");
ElementMatch match = new ElementMatch("foo", MatchMode.StartElement);
reader.MoveToContent();
reader.Read();
Assert.IsTrue(match.Matches(reader, null));
}
public void ShouldMatchElement()
{
XmlReader reader = GetReader("<root><foo></foo></root>");
ElementMatch match = new ElementMatch("foo", MatchMode.StartElement);
reader.MoveToContent();
reader.Read();
Assert.IsTrue(match.Matches(reader, null));
}
public void ElementMatchOptionDoesNotMatchEndElement()
{
XmlMatch match = new ElementMatch("bar");
XmlReader reader = GetReader("<bar></bar>");
reader.MoveToContent();
reader.Read();
Assert.IsFalse(match.Matches(reader, null));
}
public void EndElementMatchOptionMatchesEndElement()
{
XmlMatch match = new ElementMatch("bar", MatchMode.EndElement);
XmlReader reader = GetReader("<bar></bar>");
reader.MoveToContent();
reader.Read();
Assert.IsTrue(match.Matches(reader, null));
}
public void ThrowsIfPrefixUnresolvable()
{
XmlMatch match = new ElementMatch("foo", "bar");
XmlReader reader = GetReader("<bar/>");
reader.MoveToContent();
XmlNamespaceManager ns = new XmlNamespaceManager(reader.NameTable);
match.Matches(reader, ns);
}
public override MatchData Match(Element element, string pathPart)
{
var c = ElementMatch <Container> .From(element, pathPart, signatureExpr);
if (c == null)
{
return(null);
}
var sig = c.match.Groups[1].Value;
return(element.SupportsSignature(sig) ? c : null);
}
public void ShouldMatchStartElementCloseOnLastAttribute()
{
XmlReader reader = GetReader("<root id='1' title='foo'></root>");
ElementMatch match = new ElementMatch("root", MatchMode.StartElementClosed);
reader.MoveToContent();
Assert.IsFalse(match.Matches(reader, null));
reader.MoveToFirstAttribute();
Assert.IsFalse(match.Matches(reader, null));
reader.MoveToNextAttribute();
Assert.IsTrue(match.Matches(reader, null));
}
public void BothWildcardMatchesAnyElementAndNamespace()
{
XmlMatch match = new ElementMatch("*", "*");
XmlReader reader = GetReader("<foo><bar xmlns='xml-mvp'/></foo>");
reader.MoveToContent();
Assert.IsTrue(match.Matches(reader, null));
reader.Read();
Assert.IsTrue(match.Matches(reader, null));
}
public void WildcardNameDoesNotMatchWrongElementNamespace()
{
XmlMatch match = new ElementMatch("*");
XmlReader reader = GetReader("<foo xmlns='mvp-xml'><bar xmlns=''/></foo>");
reader.MoveToContent();
Assert.IsFalse(match.Matches(reader, null));
reader.Read();
Assert.IsTrue(match.Matches(reader, null));
}
public void ThrowsIfWildcardNameCannotResolvePrefix()
{
XmlMatch match = new ElementMatch("x", "*");
XmlReader reader = GetReader("<x:foo xmlns:x='xml-mvp'><x:bar/></x:foo>");
reader.MoveToContent();
XmlNamespaceManager ns = new XmlNamespaceManager(reader.NameTable);
ns.AddNamespace("y", "xml-mvp");
match.Matches(reader, ns);
}
public void MatchesNameWithPrefixDocumentWithoutPrefixButNamespace()
{
XmlMatch match = new ElementMatch("foo", "bar");
XmlReader reader = GetReader("<bar xmlns='xml-mvp'/>");
reader.MoveToContent();
XmlNamespaceManager ns = new XmlNamespaceManager(reader.NameTable);
ns.AddNamespace("foo", "xml-mvp");
Assert.IsTrue(match.Matches(reader, ns));
}
public void DoesNotMatchSameLocalNameButWrongNamespace2()
{
XmlMatch match = new ElementMatch("foo", "bar");
XmlReader reader = GetReader("<bar/>");
reader.MoveToContent();
XmlNamespaceManager ns = new XmlNamespaceManager(reader.NameTable);
ns.AddNamespace("foo", "xml-mvp");
Assert.IsFalse(match.Matches(reader, ns));
}
public void CanResolveToEmptyNamespace()
{
XmlMatch match = new ElementMatch("foo", "bar");
XmlReader reader = GetReader("<bar/>");
reader.MoveToContent();
XmlNamespaceManager ns = new XmlNamespaceManager(reader.NameTable);
ns.AddNamespace("foo", String.Empty);
Assert.IsTrue(match.Matches(reader, ns));
}
public void WildcardNameMatchesAnyElement()
{
XmlMatch match = new ElementMatch("*");
XmlReader reader = GetReader("<foo><bar/></foo>");
reader.MoveToContent();
Assert.IsTrue(match.Matches(reader, null));
reader.Read();
Assert.IsTrue(match.Matches(reader, null));
}
public void WildcardNamespaceMatchesElementsInAnyNamespace()
{
XmlMatch match = new ElementMatch("*", "foo");
XmlReader reader = GetReader("<foo><foo xmlns='mvp-xml'/></foo>");
reader.MoveToContent();
Assert.IsTrue(match.Matches(reader, null));
reader.Read();
Assert.IsTrue(match.Matches(reader, null));
}
public void ShouldMatchStartElementCloseOnLastAttribute()
{
XmlReader reader = GetReader("<root id='1' title='foo'></root>");
ElementMatch match = new ElementMatch("root", MatchMode.StartElementClosed);
reader.MoveToContent();
Assert.IsFalse(match.Matches(reader, null));
reader.MoveToFirstAttribute();
Assert.IsFalse(match.Matches(reader, null));
reader.MoveToNextAttribute();
Assert.IsTrue(match.Matches(reader, null));
}
public void MatchesLocalNameWithoutPrefix()
{
XmlMatch match = new ElementMatch("foo");
XmlReader reader = GetReader("<foo></foo>");
reader.MoveToContent();
Assert.IsTrue(match.Matches(reader, null));
reader.Read();
match = new ElementMatch("foo", MatchMode.EndElement);
Assert.IsTrue(match.Matches(reader, null));
}
public void WildcardNameMatchesAnyElementWithPrefix()
{
XmlMatch match = new ElementMatch("x", "*");
XmlReader reader = GetReader("<x:foo xmlns:x='xml-mvp'><x:bar/></x:foo>");
reader.MoveToContent();
XmlNamespaceManager ns = new XmlNamespaceManager(reader.NameTable);
ns.AddNamespace("x", "xml-mvp");
Assert.IsTrue(match.Matches(reader, ns));
reader.Read();
Assert.IsTrue(match.Matches(reader, ns));
}
public void DoesNotMatchWrongLocalName()
{
XmlMatch match = new ElementMatch("foo");
XmlReader reader = GetReader("<root><foo/></root>");
reader.MoveToContent();
Assert.IsFalse(match.Matches(reader, null));
match = new ElementMatch("foo", MatchMode.EndElement);
reader.Read();
Assert.IsFalse(match.Matches(reader, null));
reader.Read();
Assert.IsTrue(match.Matches(reader, null));
reader.Read();
Assert.IsFalse(match.Matches(reader, null));
}
public void MatchesNameWithPrefix()
{
XmlMatch match = new ElementMatch("foo", "bar");
XmlReader reader = GetReader("<foo:bar xmlns:foo='xml-mvp'></foo:bar>");
reader.MoveToContent();
XmlNamespaceManager ns = new XmlNamespaceManager(reader.NameTable);
ns.AddNamespace("foo", "xml-mvp");
Assert.IsTrue(match.Matches(reader, ns));
reader.Read();
match = new ElementMatch("foo", "bar", MatchMode.EndElement);
Assert.IsTrue(match.Matches(reader, ns));
}
public void ElementMatchOptionMatchesOnlyElement()
{
XmlMatch match = new ElementMatch("id");
XmlReader reader = GetReader("<bar id='23'>hello</bar>");
reader.MoveToContent();
reader.MoveToFirstAttribute();
Assert.IsFalse(match.Matches(reader, null));
match = new ElementMatch("hello");
reader.MoveToElement();
reader.Read();
Assert.AreEqual(XmlNodeType.Text, reader.NodeType);
Assert.IsFalse(match.Matches(reader, null));
}
private List<ElementMatch<Element>> FindCorrespondingElements(IEnumerable<Element> elementsA, Element[] elementsB)
{
var elementMatches = new List<ElementMatch<Element>>();
foreach (var element in elementsA)
{
Tuple<ElementMatch<Element>, decimal>[] matches;
if (HasSimilarElements(element, elementsB, out matches))
{
var elementMatch = new ElementMatch<Element>
{
This = element,
Matches = new Queue<Tuple<ElementMatch<Element>, decimal>>(matches)
};
elementMatch.SetToNext();
elementMatches.Add(elementMatch);
}
}
return elementMatches;
}
public void WildcardNameMatchesAnyEndElement()
{
XmlMatch match = new ElementMatch("*", MatchMode.EndElement);
XmlReader reader = GetReader("<foo><bar></bar></foo>");
reader.MoveToContent();
reader.Read();
Assert.IsFalse(match.Matches(reader, null));
reader.Read();
Assert.IsTrue(match.Matches(reader, null));
reader.Read();
Assert.IsTrue(match.Matches(reader, null));
}
public void WildcardNameDoesNotMatchWrongEndElementNamespace()
{
XmlMatch match = new ElementMatch("*", MatchMode.EndElement);
XmlReader reader = GetReader("<foo xmlns='mvp-xml'><bar xmlns=''></bar></foo>");
reader.MoveToContent();
reader.Read();
Assert.IsFalse(match.Matches(reader, null));
reader.Read();
Assert.IsTrue(match.Matches(reader, null));
reader.Read();
Assert.IsFalse(match.Matches(reader, null));
}
public void ThrowsIfWildcardNameCannotResolvePrefix()
{
XmlMatch match = new ElementMatch("x", "*");
XmlReader reader = GetReader("<x:foo xmlns:x='xml-mvp'><x:bar/></x:foo>");
reader.MoveToContent();
XmlNamespaceManager ns = new XmlNamespaceManager(reader.NameTable);
ns.AddNamespace("y", "xml-mvp");
match.Matches(reader, ns);
}
public void ElementMatchOptionMatchesOnlyElement()
{
XmlMatch match = new ElementMatch("id");
XmlReader reader = GetReader("<bar id='23'>hello</bar>");
reader.MoveToContent();
reader.MoveToFirstAttribute();
Assert.IsFalse(match.Matches(reader, null));
match = new ElementMatch("hello");
reader.MoveToElement();
reader.Read();
Assert.AreEqual(XmlNodeType.Text, reader.NodeType);
Assert.IsFalse(match.Matches(reader, null));
}
public void WildcardNamespaceMatchesEndElementsInAnyNamespace()
{
XmlMatch match = new ElementMatch("*", "foo", MatchMode.EndElement);
XmlReader reader = GetReader("<foo><foo xmlns='mvp-xml'></foo></foo>");
reader.MoveToContent();
reader.Read();
reader.Read();
Assert.IsTrue(match.Matches(reader, null));
reader.Read();
Assert.IsTrue(match.Matches(reader, null));
}
public void BothWildcardMatchesAnyEndElementAndNamespace()
{
XmlMatch match = new ElementMatch("*", "*", MatchMode.EndElement);
XmlReader reader = GetReader("<foo><bar xmlns='xml-mvp'></bar></foo>");
reader.MoveToContent();
reader.Read();
reader.Read();
Assert.IsTrue(match.Matches(reader, null));
reader.Read();
Assert.IsTrue(match.Matches(reader, null));
}
public void ToStringEqualsFullName()
{
XmlMatch name = new ElementMatch("foo", "bar");
Assert.AreEqual(name.FullName, name.ToString());
}
public void ToStringEqualsFullName()
{
XmlMatch name = new ElementMatch("foo", "bar");
Assert.AreEqual(name.FullName, name.ToString());
}
public void ThrowsIfPrefixUnresolvable()
{
XmlMatch match = new ElementMatch("foo", "bar");
XmlReader reader = GetReader("<bar/>");
reader.MoveToContent();
XmlNamespaceManager ns = new XmlNamespaceManager(reader.NameTable);
match.Matches(reader, ns);
}
public void CanGetPrefix()
{
XmlMatch match = new ElementMatch("foo", "*");
Assert.AreEqual("foo", match.Prefix);
}
public void IsAnyNamespaceIfPrefixIsWildcard()
{
XmlNameMatch name = new ElementMatch(XmlNameMatch.Wildcard, "foo");
Assert.IsTrue(name.IsAnyNamespace);
}
public void CanGetName()
{
XmlMatch match = new ElementMatch("foo");
Assert.AreEqual("foo", match.Name);
}
public void ThrowsIfWildcardNameWithPrefixAndNoResolver()
{
XmlMatch match = new ElementMatch("x", "*");
XmlReader reader = GetReader("<x:foo xmlns:x='xml-mvp'><x:bar/></x:foo>");
reader.MoveToContent();
match.Matches(reader, null);
}
public void WildcardNameMatchesAnyElementWithPrefix()
{
XmlMatch match = new ElementMatch("x", "*");
XmlReader reader = GetReader("<x:foo xmlns:x='xml-mvp'><x:bar/></x:foo>");
reader.MoveToContent();
XmlNamespaceManager ns = new XmlNamespaceManager(reader.NameTable);
ns.AddNamespace("x", "xml-mvp");
Assert.IsTrue(match.Matches(reader, ns));
reader.Read();
Assert.IsTrue(match.Matches(reader, ns));
}
public void EndElementMatchOptionMatchesEndElement()
{
XmlMatch match = new ElementMatch("bar", MatchMode.EndElement);
XmlReader reader = GetReader("<bar></bar>");
reader.MoveToContent();
reader.Read();
Assert.IsTrue(match.Matches(reader, null));
}
public void FullNameContainsPrefixAndName()
{
XmlMatch name = new ElementMatch("foo", "bar");
Assert.AreEqual("foo:bar", name.FullName);
}
public void IsAnyNameIfNameIsWildcard()
{
XmlNameMatch name = new ElementMatch(XmlNameMatch.Wildcard);
Assert.IsTrue(name.IsAnyName);
}
public void MatchesNameWithPrefix()
{
XmlMatch match = new ElementMatch("foo", "bar");
XmlReader reader = GetReader("<foo:bar xmlns:foo='xml-mvp'></foo:bar>");
reader.MoveToContent();
XmlNamespaceManager ns = new XmlNamespaceManager(reader.NameTable);
ns.AddNamespace("foo", "xml-mvp");
Assert.IsTrue(match.Matches(reader, ns));
reader.Read();
match = new ElementMatch("foo", "bar", MatchMode.EndElement);
Assert.IsTrue(match.Matches(reader, ns));
}
public void ElementMatchOptionDoesNotMatchEndElement()
{
XmlMatch match = new ElementMatch("bar");
XmlReader reader = GetReader("<bar></bar>");
reader.MoveToContent();
reader.Read();
Assert.IsFalse(match.Matches(reader, null));
}
public void FullNameDoesNotContainColonForEmptyPrefix()
{
XmlMatch name = new ElementMatch(String.Empty, "foo");
Assert.AreEqual("foo", name.FullName);
}
public void MatchThrowsIfPrefixButNoResolver()
{
XmlMatch match = new ElementMatch("foo", "bar");
XmlReader reader = GetReader("<foo:bar xmlns:foo='xml-mvp'/>");
reader.MoveToContent();
match.Matches(reader, null);
}
public void MatchesNameWithPrefixDocumentWithoutPrefixButNamespace()
{
XmlMatch match = new ElementMatch("foo", "bar");
XmlReader reader = GetReader("<bar xmlns='xml-mvp'/>");
reader.MoveToContent();
XmlNamespaceManager ns = new XmlNamespaceManager(reader.NameTable);
ns.AddNamespace("foo", "xml-mvp");
Assert.IsTrue(match.Matches(reader, ns));
}
public void FullNameContainsPrefixAndName()
{
XmlMatch name = new ElementMatch("foo", "bar");
Assert.AreEqual("foo:bar", name.FullName);
}
public void IsAnyNameIfNameIsWildcard()
{
XmlNameMatch name = new ElementMatch(XmlNameMatch.Wildcard);
Assert.IsTrue(name.IsAnyName);
}
public void DoesNotMatchSameLocalNameButWrongNamespace2()
{
XmlMatch match = new ElementMatch("foo", "bar");
XmlReader reader = GetReader("<bar/>");
reader.MoveToContent();
XmlNamespaceManager ns = new XmlNamespaceManager(reader.NameTable);
ns.AddNamespace("foo", "xml-mvp");
Assert.IsFalse(match.Matches(reader, ns));
}
public void ThrowsIfUnknownMode()
{
ElementMatch match = new ElementMatch("root", (MatchMode)10);
}
public void FullNameDoesNotContainColonForEmptyPrefix()
{
XmlMatch name = new ElementMatch(String.Empty, "foo");
Assert.AreEqual("foo", name.FullName);
}
/// <summary>
/// Attempts to determine which element on page A corresponds to which element on page B.
/// </summary>
/// <returns>A collection of mappings.</returns>
private void CorrespondingElements(Scrape pageA, Scrape pageB, decimal maxDistance)
{
var elementMatches = new List<ElementMatch<ScrapedElement>>();
foreach (var element in pageA.Elements)
{
ScrapedElement match;
Tuple<ElementMatch<ScrapedElement>, decimal>[] matches;
if (_elementMapper.HasExactMatch(element, pageB.Elements, out match) || _elementMapper.HasIdMatch(element, pageB.Elements, out match))
{
element.CorrespondingScrapedElement = match;
match.CorrespondingScrapedElement = element;
}
else if (_elementMapper.HasSimilarElements(element, pageB.Elements, maxDistance, out matches))
{
var elementMatch = new ElementMatch<ScrapedElement>
{
This = element,
Matches = new Queue<Tuple<ElementMatch<ScrapedElement>, decimal>>(matches)
};
elementMatch.SetToNext();
elementMatches.Add(elementMatch);
}
}
// Resolve conflicts
_conflictResolver.ResolveAllConflicts(elementMatches.ToArray());
foreach (var element in elementMatches.Where(m => m.Match != null))
{
element.This.CorrespondingScrapedElement = element.Match.This;
element.Match.This.CorrespondingScrapedElement = element.This;
}
}
public override MatchData Match(Element element, string pathPart)
{
return(ElementMatch <Container> .From(element, pathPart, expr));
}
public void CanResolveToEmptyNamespace()
{
XmlMatch match = new ElementMatch("foo", "bar");
XmlReader reader = GetReader("<bar/>");
reader.MoveToContent();
XmlNamespaceManager ns = new XmlNamespaceManager(reader.NameTable);
ns.AddNamespace("foo", String.Empty);
Assert.IsTrue(match.Matches(reader, ns));
}
