* System.Runtime.Serialization_test.dll.sources: Add

	  System.Xml/XmlDictionaryWriterTest.cs to the test build.
	* System.Xml/XmlDictionaryWriter.cs (WriteStartElement): Add parameter 
	  checking and default arguments to avoid NullReferenceExceptions.
	* Test/System.Xml/XmlDictionaryWriterTest.cs: Added; test
	  XmlDictionaryWriter.WriteElementString().

svn path=/trunk/mcs/; revision=126751

mcs/class/System.Runtime.Serialization/ChangeLog

@@ -1,3 +1,8 @@
+2009-02-12  Jonathan Pryor  <[email protected]>
+
+	* System.Runtime.Serialization_test.dll.sources: Add
+	  System.Xml/XmlDictionaryWriterTest.cs to the test build.
+
 2009-02-11  Jonathan Pryor  <[email protected]>
 
 	* System.Runtime.Serialization_test.dll.sources: Add

mcs/class/System.Runtime.Serialization/System.Runtime.Serialization_test.dll.sources

@@ -9,6 +9,7 @@ System.Xml/XmlDictionaryReaderAbstractTest.cs
 System.Xml/XmlDictionaryReaderQuotasTest.cs
 System.Xml/XmlDictionaryTest.cs
 System.Xml/XmlDictionaryStringTest.cs
+System.Xml/XmlDictionaryWriterTest.cs
 System.Xml/XmlSimpleDictionaryWriterTest.cs
 System.Runtime.Serialization/AttributesTest.cs
 XmlComparer.cs

mcs/class/System.Runtime.Serialization/System.Xml/ChangeLog

@@ -1,3 +1,8 @@
+2009-02-12  Jonathan Pryor  <[email protected]>
+
+	* XmlDictionaryWriter.cs (WriteStartElement): Add parameter checking
+	  and default arguments to avoid NullReferenceExceptions.
+
 2009-02-11  Jonathan Pryor  <[email protected]>
 
 	* XmlDictionaryString.cs: Add constructor argument checking.

mcs/class/System.Runtime.Serialization/System.Xml/XmlDictionaryWriter.cs

@@ -235,7 +235,10 @@ namespace System.Xml
 			XmlDictionaryString localName,
 			XmlDictionaryString namespaceUri)
 		{
-			WriteStartElement (prefix, localName.Value, namespaceUri.Value);
+			if (localName == null)
+				throw new ArgumentException ("localName must not be null.", "localName");
+			WriteStartElement (prefix, localName.Value,
+					namespaceUri != null ? namespaceUri.Value : null);
 		}
 
 		public virtual void WriteString (XmlDictionaryString value)

mcs/class/System.Runtime.Serialization/Test/System.Xml/ChangeLog

@@ -1,3 +1,8 @@
+2009-02-12  Jonathan Pryor  <[email protected]>
+
+	* XmlDictionaryWriterTest.cs: Added; test
+	  XmlDictionaryWriter.WriteElementString().
+
 2009-02-11  Jonathan Pryor  <[email protected]>
 
 	* XmlDictionaryStringTest.cs: Added; tests for XmlDictionaryString.

mcs/class/System.Runtime.Serialization/Test/System.Xml/XmlDictionaryWriterTest.cs

@@ -0,0 +1,245 @@
+//
+// XmlDictionaryWriterTest.cs
+//
+// Author:
+//   Jonathan Pryor <[email protected]>
+//
+// Copyright (C) 2009 Novell, Inc.  http://www.novell.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+#define TRACE
+
+using System;
+using System.Diagnostics;
+using System.Text;
+using System.Xml;
+using NUnit.Framework;
+
+namespace MonoTests.System.Xml
+{
+	class DelegatingXmlDictionaryWriter : XmlDictionaryWriter
+	{
+		XmlWriter d;
+
+		public DelegatingXmlDictionaryWriter (XmlWriter delegateTo)
+		{
+			d = delegateTo;
+		}
+
+		public override WriteState WriteState {
+			get {return d.WriteState;}
+		}
+
+		public override void Close ()
+		{
+			d.Close ();
+		}
+
+		public override void Flush ()
+		{
+			d.Flush ();
+		}
+
+		public override string LookupPrefix (string ns)
+		{
+			return d.LookupPrefix (ns);
+		}
+
+		public override void WriteBase64 (byte[] buffer, int index, int count)
+		{
+			d.WriteBase64 (buffer, index, count);
+		}
+
+		public override void WriteCData (string text)
+		{
+			d.WriteCData (text);
+		}
+
+		public override void WriteCharEntity (char ch)
+		{
+			d.WriteCharEntity (ch);
+		}
+
+		public override void WriteChars (char[] buffer, int index, int count)
+		{
+			d.WriteChars (buffer, index, count);
+		}
+
+		public override void WriteComment (string text)
+		{
+			d.WriteComment (text);
+		}
+
+		public override void WriteDocType (string name, string pubid, string sysid, string subset)
+		{
+			d.WriteDocType (name, pubid, sysid, subset);
+		}
+
+		public override void WriteEndAttribute ()
+		{
+			d.WriteEndAttribute ();
+		}
+
+		public override void WriteEndDocument ()
+		{
+			d.WriteEndDocument ();
+		}
+
+		public override void WriteEndElement ()
+		{
+			d.WriteEndElement ();
+		}
+
+		public override void WriteEntityRef (string name)
+		{
+			d.WriteEntityRef (name);
+		}
+
+		public override void WriteFullEndElement ()
+		{
+			d.WriteFullEndElement ();
+		}
+
+		public override void WriteProcessingInstruction (string name, string text)
+		{
+			d.WriteProcessingInstruction (name, text);
+		}
+
+		public override void WriteRaw (char[] buffer, int index, int count)
+		{
+			d.WriteRaw (buffer, index, count);
+		}
+
+		public override void WriteRaw (string data)
+		{
+			d.WriteRaw (data);
+		}
+
+		public override void WriteStartAttribute (string prefix, string localName, string ns)
+		{
+			d.WriteStartAttribute (prefix, localName, ns);
+		}
+
+		public override void WriteStartDocument ()
+		{
+			d.WriteStartDocument ();
+		}
+
+		public override void WriteStartDocument (bool standalone)
+		{
+			d.WriteStartDocument (standalone);
+		}
+
+		public override void WriteStartElement (string prefix, string localName, string ns)
+		{
+			d.WriteStartElement (prefix, localName, ns);
+		}
+
+		public override void WriteString (string text)
+		{
+			d.WriteString (text);
+		}
+
+		public override void WriteSurrogateCharEntity (char lowChar, char highChar)
+		{
+			d.WriteSurrogateCharEntity (lowChar, highChar);
+		}
+
+		public override void WriteWhitespace (string ws)
+		{
+			d.WriteWhitespace (ws);
+		}
+	}
+
+	[TestFixture]
+	public class XmlDictionaryWriterTest
+	{
+		XmlDictionaryWriter writer;
+		StringBuilder       contents;
+
+		[SetUp]
+		public void Setup()
+		{
+			var s = new XmlWriterSettings ();
+			s.ConformanceLevel   = ConformanceLevel.Fragment;
+			s.OmitXmlDeclaration = true;
+			writer = new DelegatingXmlDictionaryWriter (
+					XmlWriter.Create (contents = new StringBuilder (), s));
+		}
+
+		[TearDown]
+		public void TearDown()
+		{
+			contents = null;
+			writer   = null;
+		}
+
+		[Test, ExpectedException (typeof (ArgumentException))]
+		public void WriteElementString_localNameNull ()
+		{
+			XmlDictionaryString localName = null, namespaceUri = null;
+			string prefix = null, value = null;
+			writer.WriteElementString (prefix, localName, namespaceUri, value);
+		}
+
+		[Test, ExpectedException (typeof (ArgumentException))]
+		public void WriteElementString_PrefixWithEmptyNamespace ()
+		{
+			XmlDictionary d = new XmlDictionary ();
+			XmlDictionaryString localName = d.Add ("foo"), namespaceUri = null;
+			string prefix = "ns", value = null;
+			writer.WriteElementString (prefix, localName, namespaceUri, value);
+		}
+
+		[Test]
+		public void WriteElementString ()
+		{
+			XmlDictionary d = new XmlDictionary ();
+			XmlDictionaryString foo     = d.Add ("foo");
+			XmlDictionaryString fooUri  = d.Add ("urn:bar");
+			string             ns      = "ns";
+
+			// 
+			// Skipping empty string values because Mono & .NET generate
+			// different XML: <foo /> (Mono) vs. <foo></foo> (.NET).
+			//
+			writer.WriteElementString (null, foo, null, "data");
+			// writer.WriteElementString (null, foo, null, "");
+			writer.WriteElementString (null, foo, null, null);
+
+			writer.WriteElementString (null, foo, fooUri, "data");
+			// writer.WriteElementString (null, foo, fooUri, "");
+			writer.WriteElementString (null, foo, fooUri, null);
+
+			writer.WriteElementString (ns, foo, fooUri, "data");
+			// writer.WriteElementString (ns, foo, fooUri, "");
+			writer.WriteElementString (ns, foo, fooUri, null);
+			writer.Flush ();
+
+			Assert.AreEqual (
+					"<foo>data</foo><foo />" +
+					"<foo xmlns=\"urn:bar\">data</foo><foo xmlns=\"urn:bar\" />" +
+					"<ns:foo xmlns:ns=\"urn:bar\">data</ns:foo><ns:foo xmlns:ns=\"urn:bar\" />", 
+					contents.ToString ());
+		}
+	}
+}