Files
mono/mcs/class/System.Windows.Forms/Test/System.Resources/ResXResourceReaderTest.cs
T
Alexander Köplinger 76a01d3500 [WinForms] Make ResXResourceReader enumerator return values in same order as resx
This fixes an issue when building dotnet/corefx and all the SR.cs files are modified
because Mono used a HashTable internally in ResXResourceReader and it returned the
elements in a different order than MS.NET.

Even though this isn't explicitly mentioned in the docs, the MS.NET implementation returns
the elements in the same order as they appear in the resx and we should do the same.
2015-03-15 02:28:56 +01:00

1916 lines
67 KiB
C#

//
// ResXResourceReaderTest.cs: Unit Tests for ResXResourceReader.
//
// Authors:
// Gert Driesen <[email protected]>
// Olivier Dufour <[email protected]>
// Gary Barnett <[email protected]>
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>";
}
}