//
// ResXResourceReaderTest.cs: Unit Tests for ResXResourceReader.
//
// Authors:
//     Gert Driesen <drieseng@users.sourceforge.net>
//     Olivier Dufour <olivier.duff@gmail.com>
//     Gary Barnett <gary.barnett.mono@gmail.com>

using System;
using System.Collections;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.Resources;
using System.Text;
using System.Windows.Forms;
using System.Xml;
using System.Runtime.Serialization;

using NUnit.Framework;
using System.Reflection;

namespace MonoTests.System.Resources {
	[TestFixture]
	public class ResXResourceReaderTest : MonoTests.System.Windows.Forms.TestHelper
	{
		private string _tempDirectory;
		private string _otherTempDirectory;

		[SetUp]
		protected override void SetUp ()
		{
			_tempDirectory = Path.Combine (Path.GetTempPath (), "ResXResourceReaderTest");
			_otherTempDirectory = Path.Combine (_tempDirectory, "in");
			if (!Directory.Exists (_otherTempDirectory)) {
				Directory.CreateDirectory (_otherTempDirectory);
			}
			base.SetUp ();
		}

		[TearDown]
		protected override void TearDown ()
		{
			if (Directory.Exists (_tempDirectory))
				Directory.Delete (_tempDirectory, true);
			base.TearDown ();
		}

		[Test] // ctor (Stream)
		public void Constructor1_Stream_InvalidContent ()
		{
			MemoryStream ms = new MemoryStream ();
			ms.WriteByte (byte.MaxValue);
			ms.Position = 0;
			ResXResourceReader r = new ResXResourceReader (ms);
			try {
				r.GetEnumerator ();
				Assert.Fail ("#1");
			} catch (ArgumentException ex) {
				// Invalid ResX input
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsNull (ex.ParamName, "#4");
				Assert.IsNotNull (ex.InnerException, "#5");
			}
		}

		[Test] // ctor (Stream)
		[Category ("NotDotNet")] // MS throws a NullReferenceException in GetEnumerator ()
		public void Constructor1_Stream_Null ()
		{
			try {
				new ResXResourceReader ((Stream) null);
				Assert.Fail ("#1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.AreEqual ("stream", ex.ParamName, "#5");
			}
		}

		[Test] // ctor (String)
		public void Constructor2_FileName_DoesNotExist ()
		{
			ResXResourceReader r = new ResXResourceReader ((string) "definitelydoesnotexist.zzz");
			try {
				r.GetEnumerator ();
				Assert.Fail ("#1");
			} catch (FileNotFoundException ex) {
				Assert.AreEqual (typeof (FileNotFoundException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.FileName, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.IsNull (ex.InnerException, "#5");
			}
		}

		[Test] // ctor (TextReader)
		public void Constructor3_Reader_InvalidContent ()
		{
			StringReader sr = new StringReader ("</definitelyinvalid<");
			ResXResourceReader r = new ResXResourceReader (sr);
			try {
				r.GetEnumerator ();
				Assert.Fail ("#1");
			} catch (ArgumentException ex) {
				// Invalid ResX input
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.Message, "#3");
				Assert.IsNull (ex.ParamName, "#4");
				Assert.IsNotNull (ex.InnerException, "#5");
				Assert.AreEqual (typeof (XmlException), ex.InnerException.GetType (), "#6");
			}
		}

		[Test]
		public void Close_FileName ()
		{
			string fileName = Path.Combine (Path.Combine ("Test", "System.Resources"), "compat_1_1.resx");
			if (!File.Exists (fileName))
				fileName = String.Format ("..{0}System.Resources{0}compat_1_1.resx", Path.DirectorySeparatorChar);

			ResXResourceReader r1 = new ResXResourceReader (fileName);
			r1.GetEnumerator ();
			r1.Close ();
			r1.GetEnumerator ();

			ResXResourceReader r2 = new ResXResourceReader (fileName);
			r2.Close ();
			r2.GetEnumerator ();
			r2.Close ();
		}

		[Test]
		public void Close_Reader ()
		{
			string fileName = Path.Combine (Path.Combine ("Test", "System.Resources"), "compat_1_1.resx");
			if (!File.Exists (fileName))
				fileName = String.Format ("..{0}System.Resources{0}compat_1_1.resx", Path.DirectorySeparatorChar);

			using (StreamReader sr = new StreamReader (fileName)) {
				ResXResourceReader r = new ResXResourceReader (sr);
				Assert.IsFalse (sr.Peek () == -1, "#A1");
				r.GetEnumerator ();
				Assert.IsTrue (sr.Peek () == -1, "#A2");
				r.Close ();
				try {
					sr.Peek ();
					Assert.Fail ("#A3");
				} catch (ObjectDisposedException) {
				}
				r.GetEnumerator ();
			}

			using (StreamReader sr = new StreamReader (fileName)) {
				ResXResourceReader r = new ResXResourceReader (sr);
				r.Close ();
				try {
					sr.Peek ();
					Assert.Fail ("#B1");
				} catch (ObjectDisposedException) {
				}
				try {
					r.GetEnumerator ();
					Assert.Fail ("#B2");
				} catch (NullReferenceException) { // MS
				} catch (InvalidOperationException) { // Mono
				}
			}
		}

		[Test]
		public void Close_Stream ()
		{
			string fileName = Path.Combine (Path.Combine ("Test", "System.Resources"), "compat_1_1.resx");
			if (!File.Exists (fileName))
				fileName = String.Format ("..{0}System.Resources{0}compat_1_1.resx", Path.DirectorySeparatorChar);

			using (FileStream fs = File.OpenRead (fileName)) {
				ResXResourceReader r = new ResXResourceReader (fs);
				Assert.AreEqual (0, fs.Position, "#A1");
				r.GetEnumerator ();
				Assert.IsFalse (fs.Position == 0, "#A2");
				Assert.IsTrue (fs.CanRead, "#A3");
				r.Close ();
				Assert.IsTrue (fs.CanRead, "#A4");
				r.GetEnumerator ().MoveNext ();
			}

			using (FileStream fs = File.OpenRead (fileName)) {
				ResXResourceReader r = new ResXResourceReader (fs);
				r.Close ();
				Assert.AreEqual (0, fs.Position, "#B1");
				r.GetEnumerator ();
				Assert.IsFalse (fs.Position == 0, "#B2");
			}
		}

		[Test]
		public void ExternalFileReference_Icon ()
		{
			string refFile = Path.Combine (_tempDirectory, "32x32.ico");
			WriteEmbeddedResource ("32x32.ico", refFile);

			string resxFile = Path.Combine (_tempDirectory, "resources.resx");
			using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
				sw.Write (string.Format (CultureInfo.InvariantCulture,
					_resXFileRefTemplate, ResXResourceWriter.ResMimeType, "1.0",
					Consts.AssemblySystem_Windows_Forms, refFile,
					typeof (Bitmap).AssemblyQualifiedName, string.Empty,
					Consts.AssemblyCorlib));
			}

			using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
				IDictionaryEnumerator enumerator = r.GetEnumerator ();
				enumerator.MoveNext ();
				Assert.IsNotNull (enumerator.Current, "#A1");
				Assert.AreEqual ("foo", enumerator.Key, "#A2");
				Bitmap bitmap = enumerator.Value as Bitmap;
				Assert.IsNotNull (bitmap, "#A3");
				Assert.AreEqual (32, bitmap.Height, "#A4");
				Assert.AreEqual (32, bitmap.Width, "#A5");
			}

			File.Delete (refFile);
			File.Delete (resxFile);

			refFile = Path.Combine (_tempDirectory, "32x32.ICO");
			WriteEmbeddedResource ("32x32.ico", refFile);

			using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
				sw.Write (string.Format (CultureInfo.InvariantCulture,
					_resXFileRefTemplate, ResXResourceWriter.ResMimeType, "1.0",
					Consts.AssemblySystem_Windows_Forms, refFile,
					typeof (Bitmap).AssemblyQualifiedName, string.Empty,
					Consts.AssemblyCorlib));
			}

			using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
				IDictionaryEnumerator enumerator = r.GetEnumerator ();
				enumerator.MoveNext ();
				Assert.IsNotNull (enumerator.Current, "#B1");
				Assert.AreEqual ("foo", enumerator.Key, "#B2");
				Bitmap bitmap = enumerator.Value as Bitmap;
				Assert.IsNotNull (bitmap, "#B3");
				Assert.AreEqual (96, bitmap.Height, "#B4");
				Assert.AreEqual (96, bitmap.Width, "#B5");
			}
		}

		[Test]
		public void ExternalFileReference_RelativePath ()
		{
			string refFile = Path.Combine (_otherTempDirectory, "string.txt");
			string relRefFile = Path.Combine ("in", "string.txt");
			using (StreamWriter sw = new StreamWriter (refFile, false, Encoding.UTF8)) {
				sw.Write ("hello");
			}

			string resxFile = Path.Combine (_tempDirectory, "resources.resx");
			using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
				sw.Write (string.Format (CultureInfo.InvariantCulture,
					_resXFileRefTemplate, ResXResourceWriter.ResMimeType, "1.0",
					Consts.AssemblySystem_Windows_Forms, 
					"in" + Path.DirectorySeparatorChar + "string.txt", 
					typeof (StreamReader).AssemblyQualifiedName, string.Empty,
					Consts.AssemblyCorlib));
			}

			using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
				try {
					r.GetEnumerator ();
					Assert.Fail ("#A1");
				} catch (ArgumentException ex) {
					// Invalid ResX input
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
					Assert.IsNotNull (ex.InnerException, "#A3");
					Assert.IsNotNull (ex.Message, "#A4");
					Assert.IsNull (ex.ParamName, "#A5");

					// Could not find a part of the path "<current dir>\in\string.txt".
					// Line 1, position 821
					XmlException inner = ex.InnerException as XmlException;
					Assert.IsNotNull (inner, "#A6");
					Assert.AreEqual (typeof (XmlException), inner.GetType (), "#A7");
					Assert.IsNotNull (inner.InnerException, "#A8");
					Assert.AreEqual (1, inner.LineNumber, "#A9");
//					Assert.AreEqual (821, inner.LinePosition, "#A10");
					Assert.IsNotNull (inner.Message, "#A11");
					Assert.IsTrue (inner.Message.IndexOf (Path.Combine (
						Directory.GetCurrentDirectory (), relRefFile)) != -1, "#A12");

					// Could not find a part of the path "<current dir>\in\string.txt"
					Exception inner2 = inner.InnerException;
					Assert.AreEqual (typeof (DirectoryNotFoundException), inner2.GetType (), "#A13");
					Assert.IsNull (inner2.InnerException, "#A14");
					Assert.IsNotNull (inner2.Message, "#A15");
					Assert.IsTrue (inner2.Message.IndexOf (Path.Combine (
						Directory.GetCurrentDirectory (), relRefFile)) != -1, "#A16");
				}
				Assert.IsNull (r.BasePath, "#A17");
			}

			string originalCurrentDir = Directory.GetCurrentDirectory ();
			Directory.SetCurrentDirectory (_tempDirectory);
			try {
				using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
					IDictionaryEnumerator enumerator = r.GetEnumerator ();
					enumerator.MoveNext ();
					Assert.IsNotNull (enumerator.Current, "#B1");
					Assert.AreEqual ("foo", enumerator.Key, "#B2");
					using (StreamReader sr = enumerator.Value as StreamReader) {
						Assert.IsNotNull (sr, "#B3");
						Assert.AreEqual ("hello", sr.ReadToEnd (), "#B4");
					}
					Assert.IsNull (r.BasePath, "#B5");
				}
			} finally {
				// restore original current directory
				Directory.SetCurrentDirectory (originalCurrentDir);
			}

			using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
				r.BasePath = _tempDirectory;
				IDictionaryEnumerator enumerator = r.GetEnumerator ();
				enumerator.MoveNext ();
				Assert.IsNotNull (enumerator.Current, "#C1");
				Assert.AreEqual ("foo", enumerator.Key, "#C2");
				using (StreamReader sr = enumerator.Value as StreamReader) {
					Assert.IsNotNull (sr, "#C3");
					Assert.AreEqual ("hello", sr.ReadToEnd (), "#C4");
				}
				Assert.AreEqual (_tempDirectory, r.BasePath, "#C5");
			}

			using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
				r.BasePath = Path.GetTempPath ();
				try {
					r.GetEnumerator ();
					Assert.Fail ("#D1");
				} catch (ArgumentException ex) {
					// Invalid ResX input
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
					Assert.IsNotNull (ex.InnerException, "#D3");
					Assert.IsNotNull (ex.Message, "#D4");
					Assert.IsNull (ex.ParamName, "#D5");

					// Could not find a part of the path "<temp path>\in\string.txt".
					// Line 1, position 821
					XmlException inner = ex.InnerException as XmlException;
					Assert.IsNotNull (inner, "#D6");
					Assert.AreEqual (typeof (XmlException), inner.GetType (), "#D7");
					Assert.IsNotNull (inner.InnerException, "#D8");
					Assert.AreEqual (1, inner.LineNumber, "#D9");
//					Assert.AreEqual (821, inner.LinePosition, "#D10");
					Assert.IsNotNull (inner.Message, "#D11");
					Assert.IsTrue (inner.Message.IndexOf (Path.Combine (
						Path.GetTempPath (), relRefFile)) != -1, "#D12");

					// Could not find a part of the path "<temp path>\in\string.txt"
					Exception inner2 = inner.InnerException as Exception;
					Assert.AreEqual (typeof (DirectoryNotFoundException), inner2.GetType (), "#D13");
					Assert.IsNull (inner2.InnerException, "#D14");
					Assert.IsNotNull (inner2.Message, "#D15");
					Assert.IsTrue (inner2.Message.IndexOf (Path.Combine (
						Path.GetTempPath (), relRefFile)) != -1, "#D16");
				}
				Assert.AreEqual (Path.GetTempPath (), r.BasePath, "#D17");
			}
		}

		[Test]
		public void FileRef_String_UTF7 ()
		{
			string refFile = Path.Combine (_otherTempDirectory, "string.txt");
			using (StreamWriter sw = new StreamWriter (refFile, false, Encoding.UTF7)) {
				sw.Write ("\u0021\u0026\u002A\u003B");
			}

			string resxFile = Path.Combine (_tempDirectory, "resources.resx");
			using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
				sw.Write (string.Format (CultureInfo.InvariantCulture,
					_resXFileRefTemplate, ResXResourceWriter.ResMimeType, "1.0",
					Consts.AssemblySystem_Windows_Forms, refFile, 
					typeof (string).AssemblyQualifiedName, string.Empty,
					Consts.AssemblyCorlib));
			}

			using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
				IDictionaryEnumerator enumerator = r.GetEnumerator ();
				enumerator.MoveNext ();
				Assert.IsNotNull (enumerator.Current, "#A1");
				Assert.AreEqual ("foo", enumerator.Key, "#A2");
				Assert.IsFalse ("\u0021\u0026\u002A\u003B" == (string) enumerator.Value, "#A3");
			}

			resxFile = Path.Combine (_tempDirectory, "resources.resx");
			using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
				sw.Write (string.Format (CultureInfo.InvariantCulture,
					_resXFileRefTemplate, ResXResourceWriter.ResMimeType, "1.0",
					Consts.AssemblySystem_Windows_Forms, refFile,
					typeof (string).AssemblyQualifiedName, ";utf-7",
					Consts.AssemblyCorlib));
			}

			using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
				IDictionaryEnumerator enumerator = r.GetEnumerator ();
				enumerator.MoveNext ();
				Assert.IsNotNull (enumerator.Current, "#B1");
				Assert.AreEqual ("foo", enumerator.Key, "#B2");
				Assert.AreEqual ("\u0021\u0026\u002A\u003B", (string) enumerator.Value, "#B3");
			}
		}

		[Test]
		public void FileRef_String_UTF8 ()
		{
			string refFile = Path.Combine (_otherTempDirectory, "string.txt");
			using (StreamWriter sw = new StreamWriter (refFile, false, Encoding.UTF8)) {
				sw.Write ("\u0041\u2262\u0391\u002E");
			}

			string resxFile = Path.Combine (_tempDirectory, "resources.resx");
			using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
				sw.Write (string.Format (CultureInfo.InvariantCulture,
					_resXFileRefTemplate, ResXResourceWriter.ResMimeType, "1.0",
					Consts.AssemblySystem_Windows_Forms, refFile,
					typeof (string).AssemblyQualifiedName, string.Empty,
					Consts.AssemblyCorlib));
			}

			using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
				IDictionaryEnumerator enumerator = r.GetEnumerator ();
				enumerator.MoveNext ();
				Assert.IsNotNull (enumerator.Current, "#A1");
				Assert.AreEqual ("foo", enumerator.Key, "#A2");
				Assert.AreEqual ("\u0041\u2262\u0391\u002E", (string) enumerator.Value, "#A3");
			}

			resxFile = Path.Combine (_tempDirectory, "resources.resx");
			using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
				sw.Write (string.Format (CultureInfo.InvariantCulture,
					_resXFileRefTemplate, ResXResourceWriter.ResMimeType, "1.0",
					Consts.AssemblySystem_Windows_Forms, refFile,
					typeof (string).AssemblyQualifiedName, ";utf-8",
					Consts.AssemblyCorlib));
			}

			using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
				IDictionaryEnumerator enumerator = r.GetEnumerator ();
				enumerator.MoveNext ();
				Assert.IsNotNull (enumerator.Current, "#B1");
				Assert.AreEqual ("foo", enumerator.Key, "#B2");
				Assert.AreEqual ("\u0041\u2262\u0391\u002E", (string) enumerator.Value, "#B3");
			}
		}

		[Test]
		public void Namespaces ()
		{
			const string resXTemplate =
				"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
				"<o:Document xmlns:x=\"http://www.mono-project.com\" xmlns:o=\"http://tempuri.org\">" +
				"	<o:Content>" +
				"		<x:DaTa name=\"name\">" +
				"			<o:value>de Icaza</o:value>" +
				"		</x:DaTa>" +
				"		<x:data name=\"firstName\">" +
				"			<x:value />" +
				"		</x:data>" +
				"		<o:data name=\"Address\" />" +
				"		<o:data name=\"city\">" +
				"			<x:value>Boston </x:value>" +
				"		</o:data>" +
				"		<o:data name=\"country\">" +
				"			 United States " +
				"		</o:data>" +
				"		<o:data name=\"\">" +
				"			BO    " +
				"		</o:data>" +
				"		<o:data name=\"country\">" +
				"			<x:value>Belgium</x:value>" +
				"		</o:data>" +
				"		<data name=\"zip\">" +
				"			<value><![CDATA[ <3510> ]]></value>" +
				"		</data>" +
				"	</o:Content>" +
				"	<o:Paragraph>" +
				"		<o:resheader name=\"resmimetype\">" +
				"			<o:value>{0}</o:value>" +
				"		</o:resheader>" +
				"		<x:resheader name=\"version\">" +
				"			<o:value>{1}</o:value>" +
				"		</x:resheader>" +
				"	</o:Paragraph>" +
				"	<x:Section>" +
				"		<o:resheader name=\"reader\">" +
				"			<x:value>System.Resources.ResXResourceReader, {2}</x:value>" +
				"		</o:resheader>" +
				"		<x:resheader name=\"writer\">" +
				"			<x:value>System.Resources.ResXResourceWriter, {2}</x:value>" +
				"		</x:resheader>" +
				"	</x:Section>" +
				"</o:Document>";

			string resxFile = Path.Combine (_tempDirectory, "resources.resx");
			using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
				sw.Write (string.Format (CultureInfo.InvariantCulture,
					resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
					Consts.AssemblySystem_Windows_Forms));
			}

			// Stream
			using (FileStream fs = new FileStream (resxFile, FileMode.Open, FileAccess.Read, FileShare.Read)) {
				using (ResXResourceReader r = new ResXResourceReader (fs)) {
					IDictionaryEnumerator enumerator = r.GetEnumerator ();
					int entries = 0;
					while (enumerator.MoveNext ()) {
						entries++;
						switch ((string) enumerator.Key) {
						case "":
							Assert.IsNotNull (enumerator.Value, "#A1");
							Assert.AreEqual ("BO", enumerator.Value, "#A2");
							break;
						case "Address":
							Assert.IsNotNull (enumerator.Value, "#B1");
							Assert.AreEqual (string.Empty, enumerator.Value, "#B2");
							break;
						case "country":
							Assert.IsNotNull (enumerator.Value, "#C1");
							Assert.AreEqual (string.Empty, enumerator.Value, "#C2");
							break;
						case "firstName":
							Assert.IsNull (enumerator.Value, "#D");
							break;
						case "zip":
							Assert.IsNotNull (enumerator.Value, "#E1");
							Assert.AreEqual (" <3510> ", enumerator.Value, "#E2");
							break;
						default:
							Assert.Fail ("#F:" + enumerator.Key);
							break;
						}
					}
					Assert.AreEqual (5, entries, "#G");
				}
			}
		}

		[Test]
		public void ResHeader_Missing ()
		{
			const string resXTemplate =
				"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
				"<root>" +
				"	<data name=\"name\">" +
				"		<value>de Icaza</value>" +
				"	</data>" +
				"	<data name=\"firstName\">" +
				"		<value />" +
				"	</data>" +
				"	<data name=\"address\" />" +
				"</root>";

			string resxFile = Path.Combine (_tempDirectory, "resources.resx");
			using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
				sw.Write (resXTemplate);
			}

			// Stream
			using (FileStream fs = new FileStream (resxFile, FileMode.Open, FileAccess.Read, FileShare.Read)) {
				using (ResXResourceReader r = new ResXResourceReader (fs)) {
					try {
						r.GetEnumerator ();
						Assert.Fail ("#A1");
					} catch (ArgumentException ex) {
						//Invalid ResX input.  Could not find valid \"resheader\"
						// tags for the ResX reader & writer type names
						Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
						Assert.IsNull (ex.InnerException, "#A3");
						Assert.IsNotNull (ex.Message, "#A4");
						Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#A5");
						Assert.IsNull (ex.ParamName, "#A6");
					}
				}
			}

			// File
			using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
				try {
					r.GetEnumerator ();
					Assert.Fail ("#B1");
				} catch (ArgumentException ex) {
					//Invalid ResX input.  Could not find valid \"resheader\"
					// tags for the ResX reader & writer type names
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
					Assert.IsNull (ex.InnerException, "#B3");
					Assert.IsNotNull (ex.Message, "#B4");
					Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#B5");
					Assert.IsNull (ex.ParamName, "#B6");
				}
			}

			// TextReader
			using (StreamReader sr = new StreamReader (resxFile, Encoding.UTF8)) {
				using (ResXResourceReader r = new ResXResourceReader (sr)) {
					try {
						r.GetEnumerator ();
						Assert.Fail ("#C1");
					} catch (ArgumentException ex) {
						//Invalid ResX input.  Could not find valid \"resheader\"
						// tags for the ResX reader & writer type names
						Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
						Assert.IsNull (ex.InnerException, "#C3");
						Assert.IsNotNull (ex.Message, "#C4");
						Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#C5");
						Assert.IsNull (ex.ParamName, "#C6");
					}
				}
			}
		}

		[Test]
		public void ResHeader_ResMimeType ()
		{
			const string resXTemplate =
				"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
				"<root>" +
				"	<resheader name=\"resMIMEtype\">" +
				"		{0}" +
				"	</resheader>" +
				"	<resheader name=\"version\">" +
				"		<value>{1}</value>" +
				"	</resheader>" +
				"	<resheader name=\"reAder\">" +
				"		<value>System.Resources.ResXResourceReader, {2}</value>" +
				"	</resheader>" +
				"	<resheader name=\"wriTer\">" +
				"		<value>System.Resources.ResXResourceWriter, {2}</value>" +
				"	</resheader>" +
				"</root>";

			string resXContent = null;

			// <value> element, exact case
			resXContent = string.Format (CultureInfo.InvariantCulture,
				resXTemplate, ResXResourceWriter.ResMimeType, "1.0", 
				Consts.AssemblySystem_Windows_Forms);
			using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
				r.GetEnumerator ();
			}

			// <value> element, uppercase
			resXContent = string.Format (CultureInfo.InvariantCulture,
				resXTemplate, ResXResourceWriter.ResMimeType.ToUpper (), "1.0",
				Consts.AssemblySystem_Windows_Forms);
			using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
				try {
					r.GetEnumerator ();
					Assert.Fail ("#A1");
				} catch (ArgumentException ex) {
					//Invalid ResX input.  Could not find valid \"resheader\"
					// tags for the ResX reader & writer type names
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
					Assert.IsNull (ex.InnerException, "#A3");
					Assert.IsNotNull (ex.Message, "#A4");
					Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#A5");
					Assert.IsNull (ex.ParamName, "#A6");
				}
			}

			// text, exact case
			resXContent = string.Format (CultureInfo.InvariantCulture,
				resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
				Consts.AssemblySystem_Windows_Forms);
			using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
				r.GetEnumerator ();
			}

			// text, uppercase
			resXContent = string.Format (CultureInfo.InvariantCulture,
				resXTemplate, ResXResourceWriter.ResMimeType.ToUpper (), "1.0",
				Consts.AssemblySystem_Windows_Forms);
			using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
				try {
					r.GetEnumerator ();
					Assert.Fail ("#B1");
				} catch (ArgumentException ex) {
					//Invalid ResX input.  Could not find valid \"resheader\"
					// tags for the ResX reader & writer type names
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
					Assert.IsNull (ex.InnerException, "#B3");
					Assert.IsNotNull (ex.Message, "#B4");
					Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#B5");
					Assert.IsNull (ex.ParamName, "#B6");
				}
			}

			// CDATA, exact case
			resXContent = string.Format (CultureInfo.InvariantCulture,
				resXTemplate, "<![CDATA[" +ResXResourceWriter.ResMimeType + "]]>",
				"1.0", Consts.AssemblySystem_Windows_Forms);
			using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
				r.GetEnumerator ();
			}

			// CDATA, uppercase
			resXContent = string.Format (CultureInfo.InvariantCulture,
				resXTemplate, "<![CDATA[" + ResXResourceWriter.ResMimeType.ToUpper () + "]]>",
				"1.0", Consts.AssemblySystem_Windows_Forms);
			using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
				try {
					r.GetEnumerator ();
					Assert.Fail ("#C1");
				} catch (ArgumentException ex) {
					//Invalid ResX input.  Could not find valid \"resheader\"
					// tags for the ResX reader & writer type names
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
					Assert.IsNull (ex.InnerException, "#C3");
					Assert.IsNotNull (ex.Message, "#C4");
					Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#C5");
					Assert.IsNull (ex.ParamName, "#C6");
				}
			}

			// <whatever> element, exact case
			resXContent = string.Format (CultureInfo.InvariantCulture,
				resXTemplate, "<whatever>" + ResXResourceWriter.ResMimeType + "</whatever>",
				"1.0", Consts.AssemblySystem_Windows_Forms);
			using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
				r.GetEnumerator ();
			}

			// <whatever> element, uppercase
			resXContent = string.Format (CultureInfo.InvariantCulture,
				resXTemplate, "<whatever>" + ResXResourceWriter.ResMimeType.ToUpper () + "</whatever>",
				"1.0", Consts.AssemblySystem_Windows_Forms);
			using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
				try {
					r.GetEnumerator ();
					Assert.Fail ("#D1");
				} catch (ArgumentException ex) {
					//Invalid ResX input.  Could not find valid \"resheader\"
					// tags for the ResX reader & writer type names
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
					Assert.IsNull (ex.InnerException, "#D3");
					Assert.IsNotNull (ex.Message, "#D4");
					Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#D5");
					Assert.IsNull (ex.ParamName, "#D6");
				}
			}
		}

		[Test]
		public void ResHeader_ResMimeType_Empty ()
		{
			const string resXTemplate =
				"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
				"<root>" +
				"	<resheader name=\"resmimetype\"></resheader>" +
				"</root>";

			using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXTemplate))) {
				try {
					r.GetEnumerator ();
					Assert.Fail ("#1");
				} catch (ArgumentException ex) {
					//Invalid ResX input.  Could not find valid \"resheader\"
					// tags for the ResX reader & writer type names
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
					Assert.IsNull (ex.InnerException, "#3");
					Assert.IsNotNull (ex.Message, "#4");
					Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#5");
					Assert.IsNull (ex.ParamName, "#6");
				}
			}
		}

		[Test]
		public void ResHeader_ResMimeType_Invalid ()
		{
			const string resXTemplate =
				"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
				"<root>" +
				"	<resheader name=\"resmimetype\">" +
				"		<value>{0}</value>" +
				"	</resheader>" +
				"	<resheader name=\"version\">" +
				"		<value>{1}</value>" +
				"	</resheader>" +
				"	<resheader name=\"reader\">" +
				"		<value>System.Resources.ResXResourceReader, {2}</value>" +
				"	</resheader>" +
				"	<resheader name=\"writer\">" +
				"		<value>System.Resources.ResXResourceWriter, {2}</value>" +
				"	</resheader>" +
				"	<data name=\"name\">" +
				"		<value>de Icaza</value>" +
				"	</data>" +
				"	<data name=\"firstName\">" +
				"		<value />" +
				"	</data>" +
				"	<data name=\"Address\" />" +
				"</root>";

			string resxFile = Path.Combine (_tempDirectory, "resources.resx");
			using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
				sw.Write (string.Format (CultureInfo.InvariantCulture,
					resXTemplate, "notvalid", "1.0", Consts.AssemblySystem_Windows_Forms
					));
			}

			// Stream
			using (FileStream fs = new FileStream (resxFile, FileMode.Open, FileAccess.Read, FileShare.Read)) {
				using (ResXResourceReader r = new ResXResourceReader (fs)) {
					try {
						r.GetEnumerator ();
						Assert.Fail ("#A1");
					} catch (ArgumentException ex) {
						//Invalid ResX input.  Could not find valid \"resheader\"
						// tags for the ResX reader & writer type names
						Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
						Assert.IsNull (ex.InnerException, "#A3");
						Assert.IsNotNull (ex.Message, "#A4");
						Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#A5");
						Assert.IsNull (ex.ParamName, "#A6");
					}
				}
			}

			// File
			using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
				try {
					r.GetEnumerator ();
					Assert.Fail ("#B1");
				} catch (ArgumentException ex) {
					//Invalid ResX input.  Could not find valid \"resheader\"
					// tags for the ResX reader & writer type names
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
					Assert.IsNull (ex.InnerException, "#B3");
					Assert.IsNotNull (ex.Message, "#B4");
					Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#B5");
					Assert.IsNull (ex.ParamName, "#B6");
				}
			}

			// TextReader
			using (StreamReader sr = new StreamReader (resxFile, Encoding.UTF8)) {
				using (ResXResourceReader r = new ResXResourceReader (sr)) {
					try {
						r.GetEnumerator ();
						Assert.Fail ("#C1");
					} catch (ArgumentException ex) {
						//Invalid ResX input.  Could not find valid \"resheader\"
						// tags for the ResX reader & writer type names
						Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
						Assert.IsNull (ex.InnerException, "#C3");
						Assert.IsNotNull (ex.Message, "#C4");
						Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#C5");
						Assert.IsNull (ex.ParamName, "#C6");
					}
				}
			}
		}

		[Test]
		public void ResHeader_ResMimeType_Null ()
		{
			const string resXTemplate =
				"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
				"<root>" +
				"	<resheader name=\"resmimetype\" />" +
				"</root>";

			using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXTemplate))) {
				try {
					r.GetEnumerator ();
					Assert.Fail ("#1");
				} catch (ArgumentException ex) {
					//Invalid ResX input.  Could not find valid \"resheader\"
					// tags for the ResX reader & writer type names
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
					Assert.IsNull (ex.InnerException, "#3");
					Assert.IsNotNull (ex.Message, "#4");
					Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#5");
					Assert.IsNull (ex.ParamName, "#6");
				}
			}
		}

		[Test]
		public void ResHeader_Reader_Invalid ()
		{
			const string resXTemplate =
				"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
				"<root>" +
				"	<resheader name=\"resmimetype\">" +
				"		{0}" +
				"	</resheader>" +
				"	<resheader name=\"version\">" +
				"		<value>{1}</value>" +
				"	</resheader>" +
				"	<resheader name=\"reader\">" +
				"		<value>System.Resources.InvalidResXResourceReader, {2}</value>" +
				"	</resheader>" +
				"	<resheader name=\"writer\">" +
				"		<value>System.Resources.ResXResourceWriter, {2}</value>" +
				"	</resheader>" +
				"</root>";

			string resXContent = string.Format (CultureInfo.InvariantCulture,
				resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
				Consts.AssemblySystem_Windows_Forms);
			using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
				try {
					r.GetEnumerator ();
					Assert.Fail ("#1");
				} catch (ArgumentException ex) {
					//Invalid ResX input.  Could not find valid \"resheader\"
					// tags for the ResX reader & writer type names
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
					Assert.IsNull (ex.InnerException, "#3");
					Assert.IsNotNull (ex.Message, "#4");
					Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#5");
					Assert.IsNull (ex.ParamName, "#6");
				}
			}
		}

		[Test]
		public void ResHeader_Reader_Missing ()
		{
			const string resXTemplate =
				"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
				"<root>" +
				"	<resheader name=\"resmimetype\">" +
				"		{0}" +
				"	</resheader>" +
				"	<resheader name=\"version\">" +
				"		<value>{1}</value>" +
				"	</resheader>" +
				"	<resheader name=\"writer\">" +
				"		<value>System.Resources.ResXResourceWriter, {2}</value>" +
				"	</resheader>" +
				"</root>";

			string resXContent = string.Format (CultureInfo.InvariantCulture,
				resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
				Consts.AssemblySystem_Windows_Forms);
			using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
				try {
					r.GetEnumerator ();
					Assert.Fail ("#1");
				} catch (ArgumentException ex) {
					//Invalid ResX input.  Could not find valid \"resheader\"
					// tags for the ResX reader & writer type names
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
					Assert.IsNull (ex.InnerException, "#3");
					Assert.IsNotNull (ex.Message, "#4");
					Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#5");
					Assert.IsNull (ex.ParamName, "#6");
				}
			}
		}

		[Test]
		public void ResHeader_Reader_Null ()
		{
			const string resXTemplate =
				"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
				"<root>" +
				"	<resheader name=\"resmimetype\">" +
				"		{0}" +
				"	</resheader>" +
				"	<resheader name=\"version\">" +
				"		<value>{1}</value>" +
				"	</resheader>" +
				"	<resheader name=\"reader\" />" +
				"	<resheader name=\"writer\">" +
				"		<value>System.Resources.ResXResourceWriter, {2}</value>" +
				"	</resheader>" +
				"</root>";

			string resXContent = string.Format (CultureInfo.InvariantCulture,
				resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
				Consts.AssemblySystem_Windows_Forms);
			using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
				try {
					r.GetEnumerator ();
					Assert.Fail ("#1");
				} catch (ArgumentException ex) {
					//Invalid ResX input.  Could not find valid \"resheader\"
					// tags for the ResX reader & writer type names
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
					Assert.IsNull (ex.InnerException, "#3");
					Assert.IsNotNull (ex.Message, "#4");
					Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#5");
					Assert.IsNull (ex.ParamName, "#6");
				}
			}
		}

		[Test]
		public void ResHeader_Writer_Invalid ()
		{
			const string resXTemplate =
				"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
				"<root>" +
				"	<resheader name=\"resmimetype\">" +
				"		{0}" +
				"	</resheader>" +
				"	<resheader name=\"version\">" +
				"		<value>{1}</value>" +
				"	</resheader>" +
				"	<resheader name=\"reader\">" +
				"		<value>System.Resources.ResXResourceReader, {2}</value>" +
				"	</resheader>" +
				"	<resheader name=\"writer\">" +
				"		<value>System.Resources.InvalidResXResourceWriter, {2}</value>" +
				"	</resheader>" +
				"</root>";

			string resXContent = string.Format (CultureInfo.InvariantCulture,
				resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
				Consts.AssemblySystem_Windows_Forms);
			using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
				try {
					r.GetEnumerator ();
					Assert.Fail ("#1");
				} catch (ArgumentException ex) {
					//Invalid ResX input.  Could not find valid \"resheader\"
					// tags for the ResX reader & writer type names
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
					Assert.IsNull (ex.InnerException, "#3");
					Assert.IsNotNull (ex.Message, "#4");
					Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#5");
					Assert.IsNull (ex.ParamName, "#6");
				}
			}
		}

		[Test]
		public void ResHeader_Writer_Missing ()
		{
			const string resXTemplate =
				"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
				"<root>" +
				"	<resheader name=\"resmimetype\">" +
				"		{0}" +
				"	</resheader>" +
				"	<resheader name=\"version\">" +
				"		<value>{1}</value>" +
				"	</resheader>" +
				"	<resheader name=\"reader\">" +
				"		<value>System.Resources.ResXResourceReader, {2}</value>" +
				"	</resheader>" +
				"</root>";

			string resXContent = string.Format (CultureInfo.InvariantCulture,
				resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
				Consts.AssemblySystem_Windows_Forms);
			using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
				try {
					r.GetEnumerator ();
					Assert.Fail ("#1");
				} catch (ArgumentException ex) {
					//Invalid ResX input.  Could not find valid \"resheader\"
					// tags for the ResX reader & writer type names
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
					Assert.IsNull (ex.InnerException, "#3");
					Assert.IsNotNull (ex.Message, "#4");
					Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#5");
					Assert.IsNull (ex.ParamName, "#6");
				}
			}
		}

		[Test]
		public void ResHeader_Writer_Null ()
		{
			const string resXTemplate =
				"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
				"<root>" +
				"	<resheader name=\"resmimetype\">" +
				"		{0}" +
				"	</resheader>" +
				"	<resheader name=\"version\">" +
				"		<value>{1}</value>" +
				"	</resheader>" +
				"	<resheader name=\"reader\">" +
				"		<value>System.Resources.ResXResourceReader, {2}</value>" +
				"	</resheader>" +
				"	<resheader name=\"writer\" />" +
				"</root>";

			string resXContent = string.Format (CultureInfo.InvariantCulture,
				resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
				Consts.AssemblySystem_Windows_Forms);
			using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
				try {
					r.GetEnumerator ();
					Assert.Fail ("#1");
				} catch (ArgumentException ex) {
					//Invalid ResX input.  Could not find valid \"resheader\"
					// tags for the ResX reader & writer type names
					Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
					Assert.IsNull (ex.InnerException, "#3");
					Assert.IsNotNull (ex.Message, "#4");
					Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#5");
					Assert.IsNull (ex.ParamName, "#6");
				}
			}
		}

		[Test]
		public void ResHeader_Unknown ()
		{
			const string resXTemplate =
				"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
				"<root>" +
				"	<resheader name=\"resmimetype\">" +
				"		{0}" +
				"	</resheader>" +
				"	<resheader name=\"version\">" +	
				"		<value>{1}</value>" +
				"	</resheader>" +
				"	<resheader name=\"reader\">" +
				"		<value>  System.Resources.ResXResourceReader  , {2}</value>" +
				"	</resheader>" +
				"	<resheader name=\"writer\">" +
				"		<value>  System.Resources.ResXResourceWriter  , {2}</value>" +
				"	</resheader>" +
				"	<resheader name=\"UNKNOWN\">" +
				"		<value>whatever</value>" +
				"	</resheader>" +
				"</root>";

			string resXContent = string.Format (CultureInfo.InvariantCulture,
				resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
				Consts.AssemblySystem_Windows_Forms);
			using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
				r.GetEnumerator ();
			}
		}

		[Test]
		public void ResName_Null ()
		{
			const string resXContent =
				"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
				"<root>" +
				"	<resheader name=\"resmimetype\">" +
				"		<value>invalid</value>" +
				"	</resheader>" +
				"	<data name=\"name\">" +
				"		<value>de Icaza</value>" +
				"	</data>" +
				"	<data>" +
				"		<value>whatever</value>" +
				"	</data>" +
				"</root>";

			using (StringReader sr = new StringReader (resXContent)) {
				using (ResXResourceReader r = new ResXResourceReader (sr)) {
					try {
						r.GetEnumerator ();
						Assert.Fail ("#1");
					} catch (ArgumentException ex) {
						// Invalid ResX input.
						Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
						Assert.IsNotNull (ex.InnerException, "#3");
						Assert.IsNotNull (ex.Message, "#4");
						Assert.IsNull (ex.ParamName, "#5");

						// Could not find a name for a resource. The resource
						// value was 'whatever'. Line 1, position 200
						XmlException inner = ex.InnerException as XmlException;
						Assert.IsNotNull (inner, "#6");
						Assert.AreEqual (typeof (XmlException), inner.GetType (), "#7");
						Assert.IsNotNull (inner.InnerException, "#8");
						Assert.AreEqual (1, inner.LineNumber, "#9");
//						Assert.AreEqual (200, inner.LinePosition, "#10");
						Assert.IsNotNull (inner.Message, "#11");
						Assert.IsTrue (inner.Message.IndexOf ("'whatever'") != -1, "#12");
						Assert.IsTrue (inner.Message.IndexOf (" 1") != -1, "#13");
						//Assert.IsTrue (inner.Message.IndexOf ("200") != -1, "#14");

						// Could not find a name for a resource. The resource
						// value was 'whatever'
						ArgumentException inner2 = inner.InnerException as ArgumentException;
						Assert.IsNotNull (inner2, "#15");
						Assert.AreEqual (typeof (ArgumentException), inner2.GetType (), "#16");
						Assert.IsNull (inner2.InnerException, "#17");
						Assert.IsNotNull (inner2.Message, "#18");
						Assert.IsTrue (inner2.Message.IndexOf ("'whatever'") != -1, "#19");
						Assert.IsNull (inner2.ParamName, "#20");
					}
 				}
			}
		}

        static string resXWithEmptyName =
@"<?xml version=""1.0"" encoding=""utf-8""?>
<root>
  <resheader name=""resmimetype"">
	<value>text/microsoft-resx</value>
  </resheader>
  <resheader name=""version"">
	<value>2.0</value>
  </resheader>
  <resheader name=""reader"">
	<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name=""writer"">
	<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="""">
	<value>a resource with no name</value>
  </data>
</root>";

		static string resxWithNullRef =
@"<?xml version=""1.0"" encoding=""utf-8""?>
<root>
  <resheader name=""resmimetype"">
	<value>text/microsoft-resx</value>
  </resheader>
  <resheader name=""version"">
	<value>2.0</value>
  </resheader>
  <resheader name=""reader"">
	<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name=""writer"">
	<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name=""NullRef"" type=""System.Resources.ResXNullRef, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"">
	<value></value>
  </data>
</root>";

		[Test]
		public void ResName_Empty ()
		{
			using (StringReader sr = new StringReader (resXWithEmptyName)) {
				using (ResXResourceReader r = new ResXResourceReader (sr)) {
					IDictionaryEnumerator enumerator = r.GetEnumerator ();
					enumerator.MoveNext ();
					Assert.AreEqual ("", enumerator.Key, "#A1");
					Assert.AreEqual ("a resource with no name", (string) enumerator.Value, "#A2");
				}
			}
		}

		[Test]
		public void ResXNullRef ()
		{
			using (StringReader sr = new StringReader (resxWithNullRef)) {
				using (ResXResourceReader r = new ResXResourceReader (sr)) {
					IDictionaryEnumerator enumerator = r.GetEnumerator ();
					enumerator.MoveNext ();
					Assert.AreEqual ("NullRef", enumerator.Key, "#A1");
					Assert.IsNull (enumerator.Value, "#A2");
				}
			}
		}

		[Test]
		public void ResValue ()
		{
			string resXContent = string.Format (CultureInfo.CurrentCulture,
				"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
				"<root>" +
				"	<resheader name=\"resmimetype\">" +
				"		<value>{0}</value>" +
				"	</resheader>" +
				"	<resheader name=\"reader\">" +
				"		<value>System.Resources.ResXResourceReader, {1}</value>" +
				"	</resheader>" +
				"	<resheader name=\"writer\">" +
				"		<value>System.Resources.ResXResourceWriter, {1}</value>" +
				"	</resheader>" +
				"	<data name=\"name1\">" +
				"		<value><![CDATA[ <value1> ]]></value>" +
				"	</data>" +
				"	<data name=\"name2\">" +
				"		<value>  <![CDATA[<value2>]]>  </value>" +
				"	</data>" +
				"	<data name=\"name3\">" +
				"		  <![CDATA[<value3>]]>  " +
				"	</data>" +
				"	<data name=\"name4\">" +
				"		<value> value4 </value>" +
				"	</data>" +
				"	<data name=\"name5\">" +
				"		test<value>value5</value>" +
				"	</data>" +
				"	<data name=\"name6\">" +
				"		test1<value>value6</value>test2" +
				"	</data>" +
				"	<data name=\"name7\">" +
				"		<value>value7a</value>" +
				"		<whatever>value7b</whatever>" +
				"	</data>" +
				"	<data name=\"name8\">" +
				"		<whatever>value8</whatever>" +
				"	</data>" +
				"	<data name=\"name9\">" +
				"		<whatever>value9a</whatever>" +
				"		<whatever>value9b</whatever>" +
				"	</data>" +
				"	<data name=\"name10\">" +
				"		test<whatever>value10</whatever>" +
				"	</data>" +
				"	<data name=\"name11\">" +
				"		test1<whatever>value11</whatever>test2" +
				"	</data>" +
				"	<data name=\"name12\">" +
				"		<value> test  <![CDATA[<value12>]]>  </value>" +
				"	</data>" +
				"	<data name=\"name13\">" +
				"		 test <![CDATA[<value13>]]>  " +
				"	</data>" +
				"	<data name=\"name14\" />" +
				"	<data name=\"name15\"></data>" +
				"	<data name=\"name16\">value16</data>" +
				"	<data name=\"name17\">value17</data>" +
				"	<data name=\"name18\">" +
				"		<value>value18</value>" +
				"		<data name=\"name19\">" +
				"			<value>value18</value>" +
				"		</data>" +
				"	</data>" +
				"</root>",
				ResXResourceWriter.ResMimeType, Consts.AssemblySystem_Windows_Forms);

			using (StringReader sr = new StringReader (resXContent)) {
				using (ResXResourceReader r = new ResXResourceReader (sr)) {

					IDictionaryEnumerator enumerator = r.GetEnumerator ();
					int entries = 0;
					while (enumerator.MoveNext ()) {
						entries++;
						switch ((string) enumerator.Key) {
						case "name1":
							Assert.IsNotNull (enumerator.Value, "#A1");
							Assert.AreEqual (" <value1> ", enumerator.Value, "#A2");
							break;
						case "name2":
							Assert.IsNotNull (enumerator.Value, "#B1");
							Assert.AreEqual ("<value2>", enumerator.Value, "#B2");
							break;
						case "name3":
							Assert.IsNotNull (enumerator.Value, "#C1");
							Assert.AreEqual ("<value3>", enumerator.Value, "#C2");
							break;
						case "name4":
							Assert.IsNotNull (enumerator.Value, "#D1");
							Assert.AreEqual (" value4 ", enumerator.Value, "#D2");
							break;
						case "name5":
							Assert.IsNotNull (enumerator.Value, "#E1");
							Assert.AreEqual ("value5", enumerator.Value, "#E2");
							break;
						case "name6":
							Assert.IsNotNull (enumerator.Value, "#F1");
							Assert.AreEqual ("test2", enumerator.Value, "#F2");
							break;
						case "name7":
							Assert.IsNotNull (enumerator.Value, "#G1");
							Assert.AreEqual (string.Empty, enumerator.Value, "#G2");
							break;
						case "name8":
							Assert.IsNotNull (enumerator.Value, "#H1");
							Assert.AreEqual (string.Empty, enumerator.Value, "#H2");
							break;
						case "name9":
							Assert.IsNotNull (enumerator.Value, "#I1");
							Assert.AreEqual (string.Empty, enumerator.Value, "#I2");
							break;
						case "name10":
							Assert.IsNotNull (enumerator.Value, "#J1");
							Assert.AreEqual (string.Empty, enumerator.Value, "#J2");
							break;
						case "name11":
							Assert.IsNotNull (enumerator.Value, "#K1");
							Assert.AreEqual ("test2", enumerator.Value, "#K2");
							break;
						case "name12":
							Assert.IsNotNull (enumerator.Value, "#L1");
							Assert.AreEqual (" test  <value12>", enumerator.Value, "#L2");
							break;
						case "name13":
							Assert.IsNotNull (enumerator.Value, "#M1");
							Assert.AreEqual ("<value13>", enumerator.Value, "#M2");
							break;
						case "name14":
							Assert.IsNull (enumerator.Value, "#N1");
							break;
						case "name16":
							Assert.IsNotNull (enumerator.Value, "#O1");
							Assert.AreEqual ("value16", enumerator.Value, "#O2");
							break;
						case "name17":
							Assert.IsNotNull (enumerator.Value, "#P1");
							Assert.AreEqual ("value17", enumerator.Value, "#P2");
							break;
						case "name18":
							Assert.IsNotNull (enumerator.Value, "#Q1");
							Assert.AreEqual ("value18", enumerator.Value, "#Q2");
							break;
						default:
							Assert.Fail ("#Q:" + enumerator.Key);
							break;
						}
					}
					Assert.AreEqual (17, entries, "#Q");
				}
			}
		}

		[Test]
		public void EnumeratorOrderSameAsResx ()
		{
			string resXContent = string.Format (CultureInfo.CurrentCulture,
				"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
				"<root>" +
				"	<resheader name=\"resmimetype\">" +
				"		<value>{0}</value>" +
				"	</resheader>" +
				"	<resheader name=\"reader\">" +
				"		<value>System.Resources.ResXResourceReader, {1}</value>" +
				"	</resheader>" +
				"	<resheader name=\"writer\">" +
				"		<value>System.Resources.ResXResourceWriter, {1}</value>" +
				"	</resheader>" +
				"	<data name=\"name2\">" +
				"		<value> value5 </value>" +
				"	</data>" +
				"	<data name=\"name1\">" +
				"		<value> value4 </value>" +
				"	</data>" +
				"	<data name=\"aaa\">" +
				"		<value> value3 </value>" +
				"	</data>" +
				"	<data name=\"zzzz\">" +
				"		<value> value2 </value>" +
				"	</data>" +
				"	<data name=\"bbbbbb\">" +
				"		<value> value1 </value>" +
				"	</data>" +
				"</root>",
				ResXResourceWriter.ResMimeType, Consts.AssemblySystem_Windows_Forms);

			using (StringReader sr = new StringReader (resXContent)) {
				using (ResXResourceReader r = new ResXResourceReader (sr)) {

					IDictionaryEnumerator enumerator = r.GetEnumerator ();
					enumerator.MoveNext ();
					Assert.AreEqual ("name2", enumerator.Key, "#1");
					enumerator.MoveNext ();
					Assert.AreEqual ("name1", enumerator.Key, "#2");
					enumerator.MoveNext ();
					Assert.AreEqual ("aaa", enumerator.Key, "#3");
					enumerator.MoveNext ();
					Assert.AreEqual ("zzzz", enumerator.Key, "#4");
					enumerator.MoveNext ();
					Assert.AreEqual ("bbbbbb", enumerator.Key, "#5");
				}
			}
		}

		[Test]
		public void UseResXDataNodes ()
		{
			string refFile = Path.Combine (_tempDirectory, "32x32.ico");
			WriteEmbeddedResource ("32x32.ico", refFile);

			string resxFile = Path.Combine (_tempDirectory, "resources.resx");
			using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
				sw.Write (string.Format (CultureInfo.InvariantCulture,
					_resXFileRefTemplate, ResXResourceWriter.ResMimeType, "1.0",
					Consts.AssemblySystem_Windows_Forms, refFile,
					typeof (Bitmap).AssemblyQualifiedName, string.Empty,
					Consts.AssemblyCorlib));
			}

			using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
				r.UseResXDataNodes = true;
				IDictionaryEnumerator enumerator = r.GetEnumerator ();

				int entries = 0;
				while (enumerator.MoveNext ()) {
					entries++;

					ResXDataNode node = enumerator.Value as ResXDataNode;

					switch ((string) enumerator.Key) {
					case "foo":
						Assert.AreEqual ("foo", node.Name, "#A1");
						Bitmap bitmap = node.GetValue (new AssemblyName[] {typeof (Bitmap).Assembly.GetName ()}) as Bitmap;
						Assert.IsNotNull (bitmap, "#A2");
						break;
					case "panel_label.Locked":
						Assert.AreEqual ("panel_label.Locked", node.Name, "#B1");
						Assert.AreEqual (true, node.GetValue (new AssemblyName[] {typeof (int).Assembly.GetName ()}), "#B2");
						break;
					default:
						Assert.Fail ("#C:" + enumerator.Key);
						break;
					}
				}
				Assert.AreEqual (2, entries, "#D");
			}
		}
		
		[Test]
		[Category ("NotWorking")]
		public void ResXDataNode_GetNodePosition ()
		{
			// This test relies on a hashtable's enumerator being ordered,
			// when the ordering is not guaranteed.
			string refFile = Path.Combine (_tempDirectory, "32x32.ico");
			WriteEmbeddedResource ("32x32.ico", refFile);

			string resxFile = Path.Combine (_tempDirectory, "resources.resx");
			using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
				sw.Write (string.Format (CultureInfo.InvariantCulture,
					_resXFileRefTemplate, ResXResourceWriter.ResMimeType, "1.0",
					Consts.AssemblySystem_Windows_Forms, refFile,
					typeof (Bitmap).AssemblyQualifiedName, string.Empty,
					Consts.AssemblyCorlib));
			}

			using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
				r.UseResXDataNodes = true;
				IDictionaryEnumerator enumerator = r.GetEnumerator ();
				enumerator.MoveNext ();
				ResXDataNode node = enumerator.Value as ResXDataNode;
				Assert.IsNotNull (node, "#A1");
				Assert.AreEqual(new Point(1, 717), node.GetNodePosition (), "#A2");
			}
		}

		[Test]
		public void GetMetadataEnumerator ()
		{
			string refFile = Path.Combine (_tempDirectory, "32x32.ico");
			WriteEmbeddedResource ("32x32.ico", refFile);

			string resxFile = Path.Combine (_tempDirectory, "resources.resx");
			using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
				sw.Write (string.Format (CultureInfo.InvariantCulture,
					_resXFileRefTemplate, ResXResourceWriter.ResMimeType, "1.0",
					Consts.AssemblySystem_Windows_Forms, refFile,
					typeof (Bitmap).AssemblyQualifiedName, string.Empty,
					Consts.AssemblyCorlib));
			}

			using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
				IDictionaryEnumerator enumerator = r.GetMetadataEnumerator ();
				Assert.IsTrue (enumerator.MoveNext (), "#A1");
				Assert.IsNotNull (enumerator.Current, "#A2");
				Assert.AreEqual ("panel_label.Locked", enumerator.Key, "#A3");
				Assert.AreEqual(typeof(bool), enumerator.Value.GetType(), "#A4");
				Assert.IsTrue ((bool) enumerator.Value, "#A5");
				Assert.IsFalse (enumerator.MoveNext (), "#A6");
			}

			using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
				r.UseResXDataNodes = true;
				IDictionaryEnumerator enumerator = r.GetMetadataEnumerator ();
				Assert.IsFalse (enumerator.MoveNext (), "#B1");
			}
		}

		[Test]
		public void TypeConversion ()
		{
			string resXContent = string.Format (CultureInfo.CurrentCulture,
				"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
				"<root>" +
				"	<resheader name=\"resmimetype\">" +
				"		<value>{0}</value>" +
				"	</resheader>" +
				"	<resheader name=\"reader\">" +
				"		<value>System.Resources.ResXResourceReader, {1}</value>" +
				"	</resheader>" +
				"	<resheader name=\"writer\">" +
				"		<value>System.Resources.ResXResourceWriter, {1}</value>" +
				"	</resheader>" +
				"	<data name=\"AnchorStyle\" type=\"System.Windows.Forms.AnchorStyles, {1}\">" +
				"		<value>Bottom, Left</value>" +
				"	</data>" +
				"	<data name=\"BackgroundImage\" type=\"{2}\" mimetype=\"application/x-microsoft.net.object.bytearray.base64\">" +
				"		<value>" +
				"			Qk12BQAAAAAAADYEAAAoAAAAEgAAABAAAAABAAgAAAAAAAAAAAAgHAAAIBwAAAABAAAAAQAAAAAA/wAA" +
				"			M/8AAGb/AACZ/wAAzP8AAP//ADMA/wAzM/8AM2b/ADOZ/wAzzP8AM///AGYA/wBmM/8AZmb/AGaZ/wBm" +
				"			zP8AZv//AJkA/wCZM/8AmWb/AJmZ/wCZzP8Amf//AMwA/wDMM/8AzGb/AMyZ/wDMzP8AzP//AP8A/wD/" +
				"			M/8A/2b/AP+Z/wD/zP8A////MwAA/zMAM/8zAGb/MwCZ/zMAzP8zAP//MzMA/zMzM/8zM2b/MzOZ/zMz" +
				"			zP8zM///M2YA/zNmM/8zZmb/M2aZ/zNmzP8zZv//M5kA/zOZM/8zmWb/M5mZ/zOZzP8zmf//M8wA/zPM" +
				"			M/8zzGb/M8yZ/zPMzP8zzP//M/8A/zP/M/8z/2b/M/+Z/zP/zP8z////ZgAA/2YAM/9mAGb/ZgCZ/2YA" +
				"			zP9mAP//ZjMA/2YzM/9mM2b/ZjOZ/2YzzP9mM///ZmYA/2ZmM/9mZmb/ZmaZ/2ZmzP9mZv//ZpkA/2aZ" +
				"			M/9mmWb/ZpmZ/2aZzP9mmf//ZswA/2bMM/9mzGb/ZsyZ/2bMzP9mzP//Zv8A/2b/M/9m/2b/Zv+Z/2b/" +
				"			zP9m////mQAA/5kAM/+ZAGb/mQCZ/5kAzP+ZAP//mTMA/5kzM/+ZM2b/mTOZ/5kzzP+ZM///mWYA/5lm" +
				"			M/+ZZmb/mWaZ/5lmzP+ZZv//mZkA/5mZM/+ZmWb/mZmZ/5mZzP+Zmf//mcwA/5nMM/+ZzGb/mcyZ/5nM" +
				"			zP+ZzP//mf8A/5n/M/+Z/2b/mf+Z/5n/zP+Z////zAAA/8wAM//MAGb/zACZ/8wAzP/MAP//zDMA/8wz" +
				"			M//MM2b/zDOZ/8wzzP/MM///zGYA/8xmM//MZmb/zGaZ/8xmzP/MZv//zJkA/8yZM//MmWb/zJmZ/8yZ" +
				"			zP/Mmf//zMwA/8zMM//MzGb/zMyZ/8zMzP/MzP//zP8A/8z/M//M/2b/zP+Z/8z/zP/M/////wAA//8A" +
				"			M///AGb//wCZ//8AzP//AP///zMA//8zM///M2b//zOZ//8zzP//M////2YA//9mM///Zmb//2aZ//9m" +
				"			zP//Zv///5kA//+ZM///mWb//5mZ//+ZzP//mf///8wA///MM///zGb//8yZ///MzP//zP////8A////" +
				"			M////2b///+Z////zP//////AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA" +
				"			AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA" +
				"			AP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAAAP8AAAD/AAAA/wAA" +
				"			AAAAAAAAAAwMDAwAAAAAAAAAAAAAAAAAAAAAAAwMDAwAAAAAAAAAAAAAAAAAAAAAAAwMDAAAAAAAAAAA" +
				"			AAAAAAAAAAAAAAwMDAAAAAAAAAAAAAAAAAAAAAAADAwMAAAAAAAAAAAADAAAAAAAAAAMDA0AAAAAAAAA" +
				"			AAwMDQAAABMTExMTExMTNwAAAAAMDAwMDQAAABMTExMTExMAAAAANzc3Nzc3NwAAAD4+Pj4+AAAAAD4+" +
				"			Pj4+Pj4+PgAAAGJiYgAAAAAAAAAAYmJiAAAAAAAAAGIAAAAAAAAAAABiYmIAAAAAAAAAAAAAAAAAAAAA" +
				"			AGJiYgAAAAAAAAAAAAAAAAAAAAAAAGJiYgAAAAAAAAAAAAAAAAAAAAAAAGJiYgAAAAAAAAAAAAAAAAAA" +
				"			AAAAAGJiYgAAAAAAAAAAAAAA" +
				"		</value>" +
				"	</data>" +
				"	<data name=\"Buffer\" type=\"{3}\">" +
				"		<value>BQIH</value>" +
				"	</data>" +
				"	<data name=\"Data\" mimetype=\"application/x-microsoft.net.object.bytearray.base64\">" +
				"		<value>Random Thoughts</value>" +
				"	</data>" +
				/*s*/"	<data name=\"Foo\" type=\"System.Windows.Forms.Application, {1}\">" +
				"		<value>A B C</value>" +
				"	</data>" +
				"	<data name=\"Image\" type=\"{2}\">" +
				"		<value>Summer.jpg</value>" +
				"	</data>" +
				/*e*/"	<data name=\"Text\">" +
				"		<value>OK</value>" +
				"	</data>" +
				"	<data name=\"Unknown\" mimetype=\"application/xxx\">" +
				"		<value>MIA</value>" +
				"	</data>" +
				"	<data name=\"Wrong\" typeof=\"{2}\" mimetype=\"application/xxx\">" +
				"		<value>SuperUnknown</value>" +
				"	</data>" +
				/*s*/"	<data name=\"Xtra\" type=\"System.Windows.Forms.AnchorStyles, {1}\" mimetype=\"application/x-microsoft.net.object.bytearray.base64\">" +
				"		<value>LeftRight</value>" +
				"	</data>" +
				/*e*/"</root>",
				ResXResourceWriter.ResMimeType, Consts.AssemblySystem_Windows_Forms,
				typeof (Bitmap).AssemblyQualifiedName, typeof (byte []).AssemblyQualifiedName);

			using (StringReader sr = new StringReader (resXContent)) {
				using (ResXResourceReader r = new ResXResourceReader (sr)) {
					IDictionaryEnumerator enumerator = r.GetEnumerator ();
					int entries = 0;
					while (enumerator.MoveNext ()) {
						entries++;
						switch ((string) enumerator.Key) {
						case "AnchorStyle":
							Assert.IsNotNull (enumerator.Value, "#A1");
							Assert.AreEqual (AnchorStyles.Bottom | AnchorStyles.Left, enumerator.Value, "#A2");
							break;
						case "BackgroundImage":
							Assert.IsNotNull (enumerator.Value, "#B1");
							Assert.AreEqual (typeof (Bitmap), enumerator.Value.GetType (), "#B2");
							break;
						case "Buffer":
							Assert.IsNotNull (enumerator.Value, "#C1");
							Assert.AreEqual (new byte [] { 5, 2, 7 }, enumerator.Value, "#C2");
							break;
						case "Data":
							Assert.IsNull (enumerator.Value, "#D1");
							break;
						case "Foo":
							Assert.IsNull (enumerator.Value, "#E1");
							break;
						case "Image":
							Assert.IsNull (enumerator.Value, "#F1");
							break;
						case "Text":
							Assert.IsNotNull (enumerator.Value, "#G1");
							Assert.AreEqual ("OK", enumerator.Value, "#G2");
							break;
						case "Unknown":
							Assert.IsNull (enumerator.Value, "#H1");
							break;
						case "Wrong":
							Assert.IsNull (enumerator.Value, "#I1");
							break;
						case "Xtra":
							Assert.IsNull (enumerator.Value, "#J1");
							break;
						default:
							Assert.Fail ("#J:" + enumerator.Key);
							break;
						}
					}
					Assert.AreEqual (10, entries, "#G");
				}
			}
		}

		[Test, ExpectedException (typeof (SerializationException))]
		public void DeSerializationErrorBubbles ()
		{
			using (StringReader sr = new StringReader (serializedResXCorruped)) {
				using (ResXResourceReader r = new ResXResourceReader (sr)) {
					IDictionaryEnumerator enumerator = r.GetEnumerator ();
					// should throw exception
				}
			}
		}

		[Test, ExpectedException (typeof (TargetInvocationException))]
		public void FileRef_DeserializationFails ()
		{
			string corruptFile = Path.GetTempFileName ();
			ResXFileRef fileRef = new ResXFileRef (corruptFile, typeof (serializable).AssemblyQualifiedName);

			File.AppendAllText (corruptFile,"corrupt");

			StringBuilder sb = new StringBuilder();
			using (StringWriter sw = new StringWriter (sb)) {
				using (ResXResourceWriter writer = new ResXResourceWriter (sw)) {
					writer.AddResource ("test", fileRef);
				}
			}

			using (StringReader sr = new StringReader (sb.ToString ())) {
				using (ResXResourceReader reader = new ResXResourceReader (sr)) {
					reader.GetEnumerator ();
				}
			}
		}

		[Test, ExpectedException (typeof (ArgumentException))]
		public void FileRef_TypeCantBeResolved ()
		{
			string aFile = Path.GetTempFileName ();
			ResXFileRef fileRef = new ResXFileRef (aFile, "a.type.doesnt.exist");

			StringBuilder sb = new StringBuilder ();
			using (StringWriter sw = new StringWriter (sb)) {
				using (ResXResourceWriter writer = new ResXResourceWriter (sw)) {
					writer.AddResource ("test", fileRef);
				}
			}

			using (StringReader sr = new StringReader (sb.ToString ())) {
				using (ResXResourceReader reader = new ResXResourceReader (sr)) {
					reader.GetEnumerator ();
				}
			}
		}

		[Test]
		public void TypeConverter_AssemblyNamesUsed ()
		{
			string aName = "DummyAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null";
			AssemblyName [] assemblyNames = new AssemblyName [] { new AssemblyName (aName) };

			StringReader sr = new StringReader (convertableResXWithoutAssemblyName);

			using (ResXResourceReader rr = new ResXResourceReader (sr, assemblyNames)) {
				IDictionaryEnumerator en = rr.GetEnumerator ();
				en.MoveNext ();

				object obj = ((DictionaryEntry) en.Current).Value;
				Assert.IsNotNull (obj, "#A1");
				Assert.AreEqual ("DummyAssembly.Convertable, " + aName, obj.GetType ().AssemblyQualifiedName, "#A2");
			}

		}

		[Test]
		public void TypeConverter_ITRSUsed ()
		{
			ResXDataNode dn = new ResXDataNode ("test", 34L);

			StringBuilder sb = new StringBuilder ();
			using (StringWriter sw = new StringWriter (sb)) {
				using (ResXResourceWriter writer = new ResXResourceWriter (sw)) {
					writer.AddResource (dn);
				}
			}

			using (StringReader sr = new StringReader (sb.ToString ())) {
				ResXResourceReader rr = new ResXResourceReader (sr, new ReturnIntITRS ());
	 			IDictionaryEnumerator en = rr.GetEnumerator ();
				en.MoveNext ();

				object o = ((DictionaryEntry) en.Current).Value;
				Assert.IsNotNull (o, "#A1");
				Assert.IsInstanceOfType (typeof (int), o,"#A2");
				Assert.AreEqual (34, o,"#A3");
				rr.Close ();
			}
		}

		[Test]
		public void Serializable_ITRSUsed ()
		{
			serializable ser = new serializable ("aaaaa", "bbbbb");
			ResXDataNode dn = new ResXDataNode ("test", ser);

			StringBuilder sb = new StringBuilder ();
			using (StringWriter sw = new StringWriter (sb)) {
				using (ResXResourceWriter writer = new ResXResourceWriter (sw)) {
					writer.AddResource (dn);
				}
			}

			using (StringReader sr = new StringReader (sb.ToString ())) {
				ResXResourceReader rr = new ResXResourceReader (sr, new ReturnSerializableSubClassITRS ());
	 			
				IDictionaryEnumerator en = rr.GetEnumerator ();
				en.MoveNext ();

				object o = ((DictionaryEntry) en.Current).Value;
				Assert.IsNotNull (o, "#A1");
				Assert.IsInstanceOfType (typeof (serializableSubClass), o,"#A2");
				rr.Close ();
			}
		}

		static string convertableResXWithoutAssemblyName =
@"<?xml version=""1.0"" encoding=""utf-8""?>
<root>
  
  <resheader name=""resmimetype"">
	<value>text/microsoft-resx</value>
  </resheader>
  <resheader name=""version"">
	<value>2.0</value>
  </resheader>
  <resheader name=""reader"">
	<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name=""writer"">
	<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  
  <data name=""test"" type=""DummyAssembly.Convertable"">
	<value>im a name	im a value</value>
  </data>
</root>";

		static string serializedResXCorruped =
@"<?xml version=""1.0"" encoding=""utf-8""?>
<root>
  
  <resheader name=""resmimetype"">
	<value>text/microsoft-resx</value>
  </resheader>
  <resheader name=""version"">
	<value>2.0</value>
  </resheader>
  <resheader name=""reader"">
	<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name=""writer"">
	<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name=""test"" mimetype=""application/x-microsoft.net.object.binary.base64"">
	<value>
		AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
		AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
		AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
		AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
</value>
  </data>
</root>";

		private static void WriteEmbeddedResource (string name, string filename)
		{
			const int size = 512;
			byte [] buffer = new byte [size];
			int count = 0;

			Stream input = typeof (ResXResourceReaderTest).Assembly.
				GetManifestResourceStream (name);
			Stream output = File.Open (filename, FileMode.Create);

			try {
				while ((count = input.Read (buffer, 0, size)) > 0) {
					output.Write (buffer, 0, count);
				}
			} finally {
				output.Close ();
			}
		}

		private const string _resXFileRefTemplate =
			"<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
			"<root>" +
			"	<resheader name=\"resmimetype\">" +
			"		<value>{0}</value>" +
			"	</resheader>" +
			"	<resheader name=\"version\">" +
			"		<value>{1}</value>" +
			"	</resheader>" +
			"	<resheader name=\"reader\">" +
			"		<value>System.Resources.ResXResourceReader, {2}</value>" +
			"	</resheader>" +
			"	<resheader name=\"writer\">" +
			"		<value>System.Resources.ResXResourceWriter, {2}</value>" +
			"	</resheader>" +
			"	<metadata name=\"panel_label.Locked\" type=\"System.Boolean, {6}\">" +
			"		<value>True</value>" +
			" 	</metadata>" +
			"	<data name=\"foo\" type=\"System.Resources.ResXFileRef, {2}\">" +
			"		<value>{3};{4}{5}</value>" +
			"	</data>" +
			"</root>";
	}
}