Files
mono/mcs/class/System.XML/Test/System.Xml/XmlNamespaceManagerTests.cs
Atsushi Eno 4990b4c47b First step to import referencesource System.Xml.
It is not simply replacement because we have to workaround dynamic codegen
for Xamarin.iOS.

Also there were several tests failing with MS implementation (e.g. for
W3C DOM conformance), so we had to disable them.

There is one regression that rather needs to be fixed in Reflection.Emit.

Also, some WCF tests fail with this implementation. They need to be
investigated, reviewed and appropriately fixed.
2015-03-02 11:36:38 +08:00

287 lines
9.9 KiB
C#

//
// XmlNamespaceManagerTests.cs
//
// Authors:
// Jason Diamond ([email protected])
// Martin Willemoes Hansen ([email protected])
//
// (C) 2002 Jason Diamond http://injektilo.org/
// (C) 2003 Martin Willemoes Hansen
//
using System;
using System.Xml;
using NUnit.Framework;
namespace MonoTests.System.Xml
{
[TestFixture]
public class XmlNamespaceManagerTests
{
private XmlNameTable nameTable;
private XmlNamespaceManager namespaceManager;
[SetUp]
public void GetReady ()
{
nameTable = new NameTable ();
namespaceManager = new XmlNamespaceManager (nameTable);
}
[Test]
public void NewNamespaceManager ()
{
// make sure that you can call PopScope when there aren't any to pop.
Assert.IsTrue (!namespaceManager.PopScope ());
// the following strings should have been added to the name table by the
// namespace manager.
string xmlnsPrefix = nameTable.Get ("xmlns");
string xmlPrefix = nameTable.Get ("xml");
string stringEmpty = nameTable.Get (String.Empty);
string xmlnsNamespace = "http://www.w3.org/2000/xmlns/";
string xmlNamespace = "http://www.w3.org/XML/1998/namespace";
// none of them should be null.
Assert.IsNotNull (xmlnsPrefix);
Assert.IsNotNull (xmlPrefix);
Assert.IsNotNull (stringEmpty);
Assert.IsNotNull (xmlnsNamespace);
Assert.IsNotNull (xmlNamespace);
// Microsoft's XmlNamespaceManager reports that these three
// namespaces aren't declared for some reason.
Assert.IsTrue (!namespaceManager.HasNamespace ("xmlns"));
Assert.IsTrue (!namespaceManager.HasNamespace ("xml"));
Assert.IsTrue (!namespaceManager.HasNamespace (String.Empty));
// these three namespaces are declared by default.
Assert.AreEqual ("http://www.w3.org/2000/xmlns/", namespaceManager.LookupNamespace ("xmlns"));
Assert.AreEqual ("http://www.w3.org/XML/1998/namespace", namespaceManager.LookupNamespace ("xml"));
Assert.AreEqual (String.Empty, namespaceManager.LookupNamespace (String.Empty));
// the namespaces should be the same references found in the name table.
Assert.AreSame (xmlnsNamespace, namespaceManager.LookupNamespace ("xmlns"));
Assert.AreSame (xmlNamespace, namespaceManager.LookupNamespace ("xml"));
Assert.AreSame (stringEmpty, namespaceManager.LookupNamespace (String.Empty));
// looking up undeclared namespaces should return null.
Assert.IsNull (namespaceManager.LookupNamespace ("foo"));
}
[Test]
public void AddNamespace ()
{
// add a new namespace.
namespaceManager.AddNamespace ("foo", "http://foo/");
// make sure the new namespace is there.
Assert.IsTrue (namespaceManager.HasNamespace ("foo"));
Assert.AreEqual ("http://foo/", namespaceManager.LookupNamespace ("foo"));
// adding a different namespace with the same prefix
// is allowed.
namespaceManager.AddNamespace ("foo", "http://foo1/");
Assert.AreEqual ("http://foo1/", namespaceManager.LookupNamespace ("foo"));
}
[Test]
public void AddNamespaceWithNameTable ()
{
// add a known reference to the name table.
string fooNamespace = "http://foo/";
nameTable.Add(fooNamespace);
// create a new string with the same value but different address.
string fooNamespace2 = "http://";
fooNamespace2 += "foo/";
// the references must be different in order for this test to prove anything.
Assert.IsTrue (!Object.ReferenceEquals (fooNamespace, fooNamespace2));
// add the namespace with the reference that's not in the name table.
namespaceManager.AddNamespace ("foo", fooNamespace2);
// the returned reference should be the same one that's in the name table.
Assert.AreSame (fooNamespace, namespaceManager.LookupNamespace ("foo"));
}
[Test]
public void AddNamespace_XmlPrefix ()
{
namespaceManager.AddNamespace ("xml", "http://www.w3.org/XML/1998/namespace");
namespaceManager.AddNamespace ("XmL", "http://foo/");
namespaceManager.AddNamespace ("xmlsomething", "http://foo/");
}
[Test]
[ExpectedException (typeof (ArgumentException))]
public void AddNamespace_XmlPrefix_Invalid ()
{
namespaceManager.AddNamespace ("xml", "http://foo/");
}
[Test]
public void PushScope ()
{
// add a new namespace.
namespaceManager.AddNamespace ("foo", "http://foo/");
// make sure the new namespace is there.
Assert.IsTrue (namespaceManager.HasNamespace ("foo"));
Assert.AreEqual ("http://foo/", namespaceManager.LookupNamespace ("foo"));
// push a new scope.
namespaceManager.PushScope ();
// add a new namespace.
namespaceManager.AddNamespace ("bar", "http://bar/");
// make sure the old namespace is not in this new scope.
Assert.IsTrue (!namespaceManager.HasNamespace ("foo"));
// but we're still supposed to be able to lookup the old namespace.
Assert.AreEqual ("http://foo/", namespaceManager.LookupNamespace ("foo"));
// make sure the new namespace is there.
Assert.IsTrue (namespaceManager.HasNamespace ("bar"));
Assert.AreEqual ("http://bar/", namespaceManager.LookupNamespace ("bar"));
}
[Test]
public void PopScope ()
{
// add some namespaces and a scope.
PushScope ();
// pop the scope.
Assert.IsTrue (namespaceManager.PopScope ());
// make sure the first namespace is still there.
Assert.IsTrue (namespaceManager.HasNamespace ("foo"));
Assert.AreEqual ("http://foo/", namespaceManager.LookupNamespace ("foo"));
// make sure the second namespace is no longer there.
Assert.IsTrue (!namespaceManager.HasNamespace ("bar"));
Assert.IsNull (namespaceManager.LookupNamespace ("bar"));
// make sure there are no more scopes to pop.
Assert.IsTrue (!namespaceManager.PopScope ());
// make sure that popping again doesn't cause an exception.
Assert.IsTrue (!namespaceManager.PopScope ());
}
[Test]
public void PopScopeMustKeepAddedInScope ()
{
namespaceManager = new XmlNamespaceManager (new NameTable ()); // clear
namespaceManager .AddNamespace ("foo", "urn:foo"); // 0
namespaceManager .AddNamespace ("bar", "urn:bar"); // 0
namespaceManager .PushScope (); // 1
namespaceManager .PushScope (); // 2
namespaceManager .PopScope (); // 2
namespaceManager .PopScope (); // 1
namespaceManager .PopScope (); // 0
Assert.AreEqual ("urn:foo", namespaceManager.LookupNamespace ("foo"));
Assert.AreEqual ("urn:bar", namespaceManager.LookupNamespace ("bar"));
}
[Test]
public void AddPushPopRemove ()
{
XmlNamespaceManager nsmgr =
new XmlNamespaceManager (new NameTable ());
string ns = nsmgr.NameTable.Add ("urn:foo");
nsmgr.AddNamespace ("foo", ns);
Assert.AreEqual ("foo", nsmgr.LookupPrefix (ns));
nsmgr.PushScope ();
Assert.AreEqual ("foo", nsmgr.LookupPrefix (ns));
nsmgr.PopScope ();
Assert.AreEqual ("foo", nsmgr.LookupPrefix (ns));
nsmgr.RemoveNamespace ("foo", ns);
Assert.IsNull (nsmgr.LookupPrefix (ns));
}
[Test]
public void LookupPrefix ()
{
// This test should use an empty nametable.
XmlNamespaceManager nsmgr =
new XmlNamespaceManager (new NameTable ());
nsmgr.NameTable.Add ("urn:hoge");
nsmgr.NameTable.Add ("urn:fuga");
nsmgr.AddNamespace (string.Empty, "urn:hoge");
Assert.IsNull (nsmgr.LookupPrefix ("urn:fuga"));
Assert.AreEqual (String.Empty, nsmgr.LookupPrefix ("urn:hoge"));
}
string suffix = "oo";
[Test]
public void AtomizedLookup ()
{
if (DateTime.Now.Year == 0)
suffix = String.Empty;
XmlNamespaceManager nsmgr =
new XmlNamespaceManager (new NameTable ());
nsmgr.AddNamespace ("foo", "urn:foo");
Assert.IsNotNull (nsmgr.LookupPrefix ("urn:foo"));
// FIXME: This returns registered URI inconsistently.
// Assert.IsNull (nsmgr.LookupPrefix ("urn:f" + suffix), "It is not atomized and thus should be failed");
}
[Test]
public void TryToAddPrefixXml ()
{
NameTable nt = new NameTable ();
XmlNamespaceManager nsmgr = new XmlNamespaceManager (nt);
nsmgr.AddNamespace ("xml", "http://www.w3.org/XML/1998/namespace");
}
[Test]
[ExpectedException (typeof (ArgumentException))]
public void TryToAddPrefixXmlns ()
{
NameTable nt = new NameTable ();
XmlNamespaceManager nsmgr = new XmlNamespaceManager (nt);
nsmgr.AddNamespace ("xmlns", "http://www.w3.org/2000/xmlns/");
}
XmlNamespaceScope l = XmlNamespaceScope.Local;
XmlNamespaceScope x = XmlNamespaceScope.ExcludeXml;
XmlNamespaceScope a = XmlNamespaceScope.All;
[Test]
public void GetNamespacesInScope ()
{
XmlNamespaceManager nsmgr =
new XmlNamespaceManager (new NameTable ());
Assert.AreEqual (0, nsmgr.GetNamespacesInScope (l).Count, "#1");
Assert.AreEqual (0, nsmgr.GetNamespacesInScope (x).Count, "#2");
Assert.AreEqual (1, nsmgr.GetNamespacesInScope (a).Count, "#3");
nsmgr.AddNamespace ("foo", "urn:foo");
Assert.AreEqual (1, nsmgr.GetNamespacesInScope (l).Count, "#4");
Assert.AreEqual (1, nsmgr.GetNamespacesInScope (x).Count, "#5");
Assert.AreEqual (2, nsmgr.GetNamespacesInScope (a).Count, "#6");
// default namespace
nsmgr.AddNamespace ("", "urn:empty");
Assert.AreEqual (2, nsmgr.GetNamespacesInScope (l).Count, "#7");
Assert.AreEqual (2, nsmgr.GetNamespacesInScope (x).Count, "#8");
Assert.AreEqual (3, nsmgr.GetNamespacesInScope (a).Count, "#9");
// PushScope
nsmgr.AddNamespace ("foo", "urn:foo");
nsmgr.PushScope ();
Assert.AreEqual (0, nsmgr.GetNamespacesInScope (l).Count, "#10");
Assert.AreEqual (2, nsmgr.GetNamespacesInScope (x).Count, "#11");
Assert.AreEqual (3, nsmgr.GetNamespacesInScope (a).Count, "#12");
// PopScope
nsmgr.PopScope ();
Assert.AreEqual (2, nsmgr.GetNamespacesInScope (l).Count, "#13");
Assert.AreEqual (2, nsmgr.GetNamespacesInScope (x).Count, "#14");
Assert.AreEqual (3, nsmgr.GetNamespacesInScope (a).Count, "#15");
nsmgr.AddNamespace ("", "");
// MS bug - it should return 1 for .Local but it returns 2 instead.
//Assert.AreEqual (1, nsmgr.GetNamespacesInScope (l).Count, "#16");
Assert.AreEqual (1, nsmgr.GetNamespacesInScope (x).Count, "#17");
Assert.AreEqual (2, nsmgr.GetNamespacesInScope (a).Count, "#18");
}
}
}