mcs/class/Managed.Windows.Forms/Test/System.Resources/ResXResourceReaderTest.cs

   1 //
   2 // ResXResourceReaderTest.cs: Unit Tests for ResXResourceReader.
   3 //
   4 // Authors:
   5 //     Gert Driesen <drieseng@users.sourceforge.net>
   6 //
   7
   8 using System;
   9 using System.Collections;
  10 using System.Globalization;
  11 using System.IO;
  12 using System.Resources;
  13 using System.Text;
  14 using System.Xml;
  15
  16 using NUnit.Framework;
  17
  18 namespace MonoTests.System.Resources
  19 {
  20         [TestFixture]
  21         public class ResXResourceReaderTest
  22         {
  23                 private string _tempDirectory;
  24                 private string _otherTempDirectory;
  25
  26                 [SetUp]
  27                 public void SetUp ()
  28                 {
  29                         _tempDirectory = Path.Combine (Path.GetTempPath (), "ResXResourceReaderTest");
  30                         _otherTempDirectory = Path.Combine (_tempDirectory, "in");
  31                         if (!Directory.Exists (_otherTempDirectory)) {
  32                                 Directory.CreateDirectory (_otherTempDirectory);
  33                         }
  34                 }
  35
  36                 [TearDown]
  37                 public void TearDown ()
  38                 {
  39                         if (Directory.Exists (_tempDirectory))
  40                                 Directory.Delete (_tempDirectory, true);
  41                 }
  42
  43                 [Test]
  44                 public void Constructor1_Stream_InvalidContent ()
  45                 {
  46                         MemoryStream ms = new MemoryStream ();
  47                         ms.WriteByte (byte.MaxValue);
  48                         ms.Position = 0;
  49                         ResXResourceReader r = new ResXResourceReader (ms);
  50                         try {
  51                                 r.GetEnumerator ();
  52                                 Assert.Fail ("#1");
  53                         } catch (ArgumentException ex) {
  54                                 // Invalid ResX input
  55                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
  56                                 Assert.IsNotNull (ex.Message, "#3");
  57                                 Assert.IsNull (ex.ParamName, "#4");
  58                                 Assert.IsNotNull (ex.InnerException, "#5");
  59                         }
  60                 }
  61
  62                 [Test]
  63                 public void Constructor2_FileName_DoesNotExist ()
  64                 {
  65                         ResXResourceReader r = new ResXResourceReader ((string) "definitelydoesnotexist.zzz");
  66                         try {
  67                                 r.GetEnumerator ();
  68                                 Assert.Fail ("#1");
  69                         } catch (FileNotFoundException ex) {
  70                                 Assert.AreEqual (typeof (FileNotFoundException), ex.GetType (), "#2");
  71                                 Assert.IsNotNull (ex.FileName, "#3");
  72                                 Assert.IsNotNull (ex.Message, "#4");
  73                                 Assert.IsNull (ex.InnerException, "#5");
  74                         }
  75                 }
  76
  77                 [Test]
  78                 public void Constructor3_Reader_InvalidContent ()
  79                 {
  80                         StringReader sr = new StringReader ("</definitelyinvalid<");
  81                         ResXResourceReader r = new ResXResourceReader (sr);
  82                         try {
  83                                 r.GetEnumerator ();
  84                                 Assert.Fail ("#1");
  85                         } catch (ArgumentException ex) {
  86                                 // Invalid ResX input
  87                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
  88                                 Assert.IsNotNull (ex.Message, "#3");
  89                                 Assert.IsNull (ex.ParamName, "#4");
  90                                 Assert.IsNotNull (ex.InnerException, "#5");
  91                                 Assert.AreEqual (typeof (XmlException), ex.InnerException.GetType (), "#6");
  92                         }
  93                 }
  94
  95                 [Test]
  96                 public void Close_FileName ()
  97                 {
  98                         string fileName = Path.Combine (Path.Combine ("Test", "System.Resources"), "compat_1_1.resx");
  99
 100                         ResXResourceReader r1 = new ResXResourceReader (fileName);
 101                         r1.GetEnumerator ();
 102                         r1.Close ();
 103                         r1.GetEnumerator ();
 104
 105                         ResXResourceReader r2 = new ResXResourceReader (fileName);
 106                         r2.Close ();
 107                         r2.GetEnumerator ();
 108                         r2.Close ();
 109                 }
 110
 111                 [Test]
 112                 public void Close_Reader ()
 113                 {
 114                         string fileName = Path.Combine (Path.Combine ("Test", "System.Resources"), "compat_1_1.resx");
 115
 116                         using (StreamReader sr = new StreamReader (fileName)) {
 117                                 ResXResourceReader r = new ResXResourceReader (sr);
 118                                 Assert.IsFalse (sr.Peek () == -1, "#A1");
 119                                 r.GetEnumerator ();
 120                                 Assert.IsTrue (sr.Peek () == -1, "#A2");
 121                                 r.Close ();
 122                                 try {
 123                                         sr.Peek ();
 124                                         Assert.Fail ("#A3");
 125                                 } catch (ObjectDisposedException) {
 126                                 }
 127                                 r.GetEnumerator ();
 128                         }
 129
 130                         using (StreamReader sr = new StreamReader (fileName)) {
 131                                 ResXResourceReader r = new ResXResourceReader (sr);
 132                                 r.Close ();
 133                                 try {
 134                                         sr.Peek ();
 135                                         Assert.Fail ("#B1");
 136                                 } catch (ObjectDisposedException) {
 137                                 }
 138                                 try {
 139                                         r.GetEnumerator ();
 140                                         Assert.Fail ("#B2");
 141                                 } catch (NullReferenceException) { // MS
 142                                 } catch (InvalidOperationException) { // Mono
 143                                 }
 144                         }
 145                 }
 146
 147                 [Test]
 148                 public void Close_Stream ()
 149                 {
 150                         string fileName = Path.Combine (Path.Combine ("Test", "System.Resources"), "compat_1_1.resx");
 151
 152                         using (FileStream fs = File.OpenRead (fileName)) {
 153                                 ResXResourceReader r = new ResXResourceReader (fs);
 154                                 Assert.AreEqual (0, fs.Position, "#A1");
 155                                 r.GetEnumerator ();
 156                                 Assert.IsFalse (fs.Position == 0, "#A2");
 157                                 Assert.IsTrue (fs.CanRead, "#A3");
 158                                 r.Close ();
 159                                 Assert.IsTrue (fs.CanRead, "#A4");
 160                                 r.GetEnumerator ().MoveNext ();
 161                         }
 162
 163                         using (FileStream fs = File.OpenRead (fileName)) {
 164                                 ResXResourceReader r = new ResXResourceReader (fs);
 165                                 r.Close ();
 166                                 Assert.AreEqual (0, fs.Position, "#B1");
 167                                 r.GetEnumerator ();
 168                                 Assert.IsFalse (fs.Position == 0, "#B2");
 169                         }
 170                 }
 171
 172                 [Test]
 173                 public void ExternalFileReference_RelativePath ()
 174                 {
 175                         string refFile = Path.Combine (_otherTempDirectory, "string.txt");
 176                         string relRefFile = Path.Combine ("in", "string.txt");
 177                         using (StreamWriter sw = new StreamWriter (refFile, false, Encoding.UTF8)) {
 178                                 sw.Write ("hello");
 179                         }
 180
 181                         string resxFile = Path.Combine (_tempDirectory, "resources.resx");
 182                         using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
 183                                 sw.Write (string.Format (CultureInfo.InvariantCulture,
 184                                         _resXFileRefTemplate, ResXResourceWriter.ResMimeType, "1.0",
 185                                         Consts.AssemblySystem_Windows_Forms,
 186                                         "in" + Path.DirectorySeparatorChar + "string.txt",
 187                                         typeof (StreamReader).AssemblyQualifiedName, string.Empty));
 188                         }
 189
 190                         using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
 191                                 try {
 192                                         r.GetEnumerator ();
 193                                         Assert.Fail ("#A1");
 194                                 } catch (ArgumentException ex) {
 195                                         // Invalid ResX input
 196                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 197                                         Assert.IsNotNull (ex.InnerException, "#A3");
 198                                         Assert.IsNotNull (ex.Message, "#A4");
 199                                         Assert.IsNull (ex.ParamName, "#A5");
 200
 201 #if NET_2_0
 202                                         // Could not find a part of the path "<current dir>\in\string.txt".
 203                                         // Line 1, position 821
 204                                         XmlException inner = ex.InnerException as XmlException;
 205                                         Assert.IsNotNull (inner, "#A6");
 206                                         Assert.AreEqual (typeof (XmlException), inner.GetType (), "#A7");
 207                                         Assert.IsNotNull (inner.InnerException, "#A8");
 208                                         Assert.AreEqual (1, inner.LineNumber, "#A9");
 209                                         Assert.AreEqual (821, inner.LinePosition, "#A10");
 210                                         Assert.IsNotNull (inner.Message, "#A11");
 211                                         Assert.IsTrue (inner.Message.IndexOf (Path.Combine (
 212                                                 Directory.GetCurrentDirectory (), relRefFile)) != -1, "#A12");
 213
 214                                         // Could not find a part of the path "<current dir>\in\string.txt"
 215                                         Exception inner2 = inner.InnerException;
 216                                         Assert.AreEqual (typeof (DirectoryNotFoundException), inner2.GetType (), "#A13");
 217                                         Assert.IsNull (inner2.InnerException, "#A14");
 218                                         Assert.IsNotNull (inner2.Message, "#A15");
 219                                         Assert.IsTrue (inner2.Message.IndexOf (Path.Combine (
 220                                                 Directory.GetCurrentDirectory (), relRefFile)) != -1, "#A16");
 221 #else
 222                                         // Could not find a part of the path "<current dir>\in\string.txt"
 223                                         Exception inner = ex.InnerException;
 224                                         Assert.AreEqual (typeof (DirectoryNotFoundException), inner.GetType (), "#A6");
 225                                         Assert.IsNull (inner.InnerException, "#A7");
 226                                         Assert.IsNotNull (inner.Message, "#A8");
 227                                         Assert.IsTrue (inner.Message.IndexOf (Path.Combine (
 228                                                 Directory.GetCurrentDirectory (), relRefFile)) != -1, "#A9");
 229 #endif
 230                                 }
 231 #if NET_2_0
 232                                 Assert.IsNull (r.BasePath, "#A17");
 233 #endif
 234                         }
 235
 236                         string originalCurrentDir = Directory.GetCurrentDirectory ();
 237                         Directory.SetCurrentDirectory (_tempDirectory);
 238                         try {
 239                                 using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
 240                                         IDictionaryEnumerator enumerator = r.GetEnumerator ();
 241                                         enumerator.MoveNext ();
 242                                         Assert.IsNotNull (enumerator.Current, "#B1");
 243                                         Assert.AreEqual ("foo", enumerator.Key, "#B2");
 244                                         using (StreamReader sr = enumerator.Value as StreamReader) {
 245                                                 Assert.IsNotNull (sr, "#B3");
 246                                                 Assert.AreEqual ("hello", sr.ReadToEnd (), "#B4");
 247                                         }
 248 #if NET_2_0
 249                                         Assert.IsNull (r.BasePath, "#B5");
 250 #endif
 251                                 }
 252                         } finally {
 253                                 // restore original current directory
 254                                 Directory.SetCurrentDirectory (originalCurrentDir);
 255                         }
 256
 257 #if NET_2_0
 258                         using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
 259                                 r.BasePath = _tempDirectory;
 260                                 IDictionaryEnumerator enumerator = r.GetEnumerator ();
 261                                 enumerator.MoveNext ();
 262                                 Assert.IsNotNull (enumerator.Current, "#C1");
 263                                 Assert.AreEqual ("foo", enumerator.Key, "#C2");
 264                                 using (StreamReader sr = enumerator.Value as StreamReader) {
 265                                         Assert.IsNotNull (sr, "#C3");
 266                                         Assert.AreEqual ("hello", sr.ReadToEnd (), "#C4");
 267                                 }
 268                                 Assert.AreEqual (_tempDirectory, r.BasePath, "#C5");
 269                         }
 270
 271                         using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
 272                                 r.BasePath = Path.GetTempPath ();
 273                                 try {
 274                                         r.GetEnumerator ();
 275                                         Assert.Fail ("#D1");
 276                                 } catch (ArgumentException ex) {
 277                                         // Invalid ResX input
 278                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
 279                                         Assert.IsNotNull (ex.InnerException, "#D3");
 280                                         Assert.IsNotNull (ex.Message, "#D4");
 281                                         Assert.IsNull (ex.ParamName, "#D5");
 282
 283                                         // Could not find a part of the path "<temp path>\in\string.txt".
 284                                         // Line 1, position 821
 285                                         XmlException inner = ex.InnerException as XmlException;
 286                                         Assert.IsNotNull (inner, "#D6");
 287                                         Assert.AreEqual (typeof (XmlException), inner.GetType (), "#D7");
 288                                         Assert.IsNotNull (inner.InnerException, "#D8");
 289                                         Assert.AreEqual (1, inner.LineNumber, "#D9");
 290                                         Assert.AreEqual (821, inner.LinePosition, "#D10");
 291                                         Assert.IsNotNull (inner.Message, "#D11");
 292                                         Assert.IsTrue (inner.Message.IndexOf (Path.Combine (
 293                                                 Path.GetTempPath (), relRefFile)) != -1, "#D12");
 294
 295                                         // Could not find a part of the path "<temp path>\in\string.txt"
 296                                         Exception inner2 = inner.InnerException as Exception;
 297                                         Assert.AreEqual (typeof (DirectoryNotFoundException), inner2.GetType (), "#D13");
 298                                         Assert.IsNull (inner2.InnerException, "#D14");
 299                                         Assert.IsNotNull (inner2.Message, "#D15");
 300                                         Assert.IsTrue (inner2.Message.IndexOf (Path.Combine (
 301                                                 Path.GetTempPath (), relRefFile)) != -1, "#D16");
 302                                 }
 303                                 Assert.AreEqual (Path.GetTempPath (), r.BasePath, "#D17");
 304                         }
 305 #endif
 306                 }
 307
 308                 [Test]
 309                 public void FileRef_String_UTF7 ()
 310                 {
 311                         string refFile = Path.Combine (_otherTempDirectory, "string.txt");
 312                         using (StreamWriter sw = new StreamWriter (refFile, false, Encoding.UTF7)) {
 313                                 sw.Write ("\u0021\u0026\u002A\u003B");
 314                         }
 315
 316                         string resxFile = Path.Combine (_tempDirectory, "resources.resx");
 317                         using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
 318                                 sw.Write (string.Format (CultureInfo.InvariantCulture,
 319                                         _resXFileRefTemplate, ResXResourceWriter.ResMimeType, "1.0",
 320                                         Consts.AssemblySystem_Windows_Forms, refFile,
 321                                         typeof (string).AssemblyQualifiedName, string.Empty));
 322                         }
 323
 324                         using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
 325 #if NET_2_0
 326                                 IDictionaryEnumerator enumerator = r.GetEnumerator ();
 327                                 enumerator.MoveNext ();
 328                                 Assert.IsNotNull (enumerator.Current, "#A1");
 329                                 Assert.AreEqual ("foo", enumerator.Key, "#A2");
 330                                 Assert.IsFalse ("\u0021\u0026\u002A\u003B" == (string) enumerator.Value, "#A3");
 331 #else
 332                                 try {
 333                                         r.GetEnumerator ();
 334                                         Assert.Fail ("#A1");
 335                                 } catch (ArgumentException ex) {
 336                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 337                                         Assert.IsNotNull (ex.InnerException, "#A3");
 338                                         Assert.IsNotNull (ex.Message, "#A4");
 339                                         Assert.IsNull (ex.ParamName, "#A5");
 340
 341                                         Assert.AreEqual (typeof (MissingMethodException), ex.InnerException.GetType (), "#A6");
 342                                 }
 343 #endif
 344                         }
 345
 346                         resxFile = Path.Combine (_tempDirectory, "resources.resx");
 347                         using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
 348                                 sw.Write (string.Format (CultureInfo.InvariantCulture,
 349                                         _resXFileRefTemplate, ResXResourceWriter.ResMimeType, "1.0",
 350                                         Consts.AssemblySystem_Windows_Forms, refFile,
 351                                         typeof (string).AssemblyQualifiedName, ";utf-7"));
 352                         }
 353
 354                         using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
 355 #if NET_2_0
 356                                 IDictionaryEnumerator enumerator = r.GetEnumerator ();
 357                                 enumerator.MoveNext ();
 358                                 Assert.IsNotNull (enumerator.Current, "#B1");
 359                                 Assert.AreEqual ("foo", enumerator.Key, "#B2");
 360                                 Assert.AreEqual ("\u0021\u0026\u002A\u003B", (string) enumerator.Value, "#B3");
 361 #else
 362                                 try {
 363                                         r.GetEnumerator ();
 364                                         Assert.Fail ("#B1");
 365                                 } catch (ArgumentException ex) {
 366                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 367                                         Assert.IsNotNull (ex.InnerException, "#B3");
 368                                         Assert.IsNotNull (ex.Message, "#B4");
 369                                         Assert.IsNull (ex.ParamName, "#B5");
 370
 371                                         Assert.AreEqual (typeof (MissingMethodException), ex.InnerException.GetType (), "#B6");
 372                                 }
 373 #endif
 374                         }
 375                 }
 376
 377                 [Test]
 378                 public void FileRef_String_UTF8 ()
 379                 {
 380                         string refFile = Path.Combine (_otherTempDirectory, "string.txt");
 381                         using (StreamWriter sw = new StreamWriter (refFile, false, Encoding.UTF8)) {
 382                                 sw.Write ("\u0041\u2262\u0391\u002E");
 383                         }
 384
 385                         string resxFile = Path.Combine (_tempDirectory, "resources.resx");
 386                         using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
 387                                 sw.Write (string.Format (CultureInfo.InvariantCulture,
 388                                         _resXFileRefTemplate, ResXResourceWriter.ResMimeType, "1.0",
 389                                         Consts.AssemblySystem_Windows_Forms, refFile,
 390                                         typeof (string).AssemblyQualifiedName, string.Empty));
 391                         }
 392
 393                         using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
 394 #if NET_2_0
 395                                 IDictionaryEnumerator enumerator = r.GetEnumerator ();
 396                                 enumerator.MoveNext ();
 397                                 Assert.IsNotNull (enumerator.Current, "#A1");
 398                                 Assert.AreEqual ("foo", enumerator.Key, "#A2");
 399                                 Assert.AreEqual ("\u0041\u2262\u0391\u002E", (string) enumerator.Value, "#A3");
 400 #else
 401                                 try {
 402                                         r.GetEnumerator ();
 403                                         Assert.Fail ("#A1");
 404                                 } catch (ArgumentException ex) {
 405                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 406                                         Assert.IsNotNull (ex.InnerException, "#A3");
 407                                         Assert.IsNotNull (ex.Message, "#A4");
 408                                         Assert.IsNull (ex.ParamName, "#A5");
 409
 410                                         Assert.AreEqual (typeof (MissingMethodException), ex.InnerException.GetType (), "#A6");
 411                                 }
 412 #endif
 413                         }
 414
 415                         resxFile = Path.Combine (_tempDirectory, "resources.resx");
 416                         using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
 417                                 sw.Write (string.Format (CultureInfo.InvariantCulture,
 418                                         _resXFileRefTemplate, ResXResourceWriter.ResMimeType, "1.0",
 419                                         Consts.AssemblySystem_Windows_Forms, refFile,
 420                                         typeof (string).AssemblyQualifiedName, ";utf-8"));
 421                         }
 422
 423                         using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
 424 #if NET_2_0
 425                                 IDictionaryEnumerator enumerator = r.GetEnumerator ();
 426                                 enumerator.MoveNext ();
 427                                 Assert.IsNotNull (enumerator.Current, "#B1");
 428                                 Assert.AreEqual ("foo", enumerator.Key, "#B2");
 429                                 Assert.AreEqual ("\u0041\u2262\u0391\u002E", (string) enumerator.Value, "#B3");
 430 #else
 431                                 try {
 432                                         r.GetEnumerator ();
 433                                         Assert.Fail ("#B1");
 434                                 } catch (ArgumentException ex) {
 435                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 436                                         Assert.IsNotNull (ex.InnerException, "#B3");
 437                                         Assert.IsNotNull (ex.Message, "#B4");
 438                                         Assert.IsNull (ex.ParamName, "#B5");
 439
 440                                         Assert.AreEqual (typeof (MissingMethodException), ex.InnerException.GetType (), "#B6");
 441                                 }
 442 #endif
 443                         }
 444                 }
 445
 446                 [Test]
 447                 public void Namespaces ()
 448                 {
 449                         const string resXTemplate =
 450                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
 451                                 "<o:Document xmlns:x=\"http://www.mono-project.com\" xmlns:o=\"http://tempuri.org\">" +
 452                                 "       <o:Content>" +
 453                                 "               <x:DaTa name=\"name\">" +
 454                                 "                       <o:value>de Icaza</o:value>" +
 455                                 "               </x:DaTa>" +
 456                                 "                       <x:data name=\"firstName\">" +
 457                                 "                       <x:value />" +
 458                                 "               </x:data>" +
 459                                 "               <o:data name=\"Address\" />" +
 460                                 "               <o:data name=\"city\">" +
 461                                 "                       <x:value>Boston </x:value>" +
 462                                 "               </o:data>" +
 463                                 "               <o:data name=\"country\">" +
 464                                 "                        United States " +
 465                                 "               </o:data>" +
 466                                 "               <o:data name=\"\">" +
 467                                 "                       BO    " +
 468                                 "               </o:data>" +
 469                                 "               <o:data name=\"country\">" +
 470                                 "                       <x:value>Belgium</x:value>" +
 471                                 "               </o:data>" +
 472                                 "               <data name=\"zip\">" +
 473                                 "                       <value><![CDATA[ <3510> ]]></value>" +
 474                                 "               </data>" +
 475                                 "       </o:Content>" +
 476                                 "       <o:Paragraph>" +
 477                                 "               <o:resheader name=\"resmimetype\">" +
 478                                 "                       <o:value>{0}</o:value>" +
 479                                 "               </o:resheader>" +
 480                                 "               <x:resheader name=\"version\">" +
 481                                 "                       <o:value>{1}</o:value>" +
 482                                 "               </x:resheader>" +
 483                                 "       </o:Paragraph>" +
 484                                 "       <x:Section>" +
 485                                 "               <o:resheader name=\"reader\">" +
 486                                 "                       <x:value>System.Resources.ResXResourceReader, {2}</x:value>" +
 487                                 "               </o:resheader>" +
 488                                 "               <x:resheader name=\"writer\">" +
 489                                 "                       <x:value>System.Resources.ResXResourceWriter, {2}</x:value>" +
 490                                 "               </x:resheader>" +
 491                                 "       </x:Section>" +
 492                                 "</o:Document>";
 493
 494                         string resxFile = Path.Combine (_tempDirectory, "resources.resx");
 495                         using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
 496                                 sw.Write (string.Format (CultureInfo.InvariantCulture,
 497                                         resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
 498                                         Consts.AssemblySystem_Windows_Forms));
 499                         }
 500
 501                         // Stream
 502                         using (FileStream fs = new FileStream (resxFile, FileMode.Open, FileAccess.Read, FileShare.Read)) {
 503                                 using (ResXResourceReader r = new ResXResourceReader (fs)) {
 504                                         IDictionaryEnumerator enumerator = r.GetEnumerator ();
 505                                         int entries = 0;
 506                                         while (enumerator.MoveNext ()) {
 507                                                 entries++;
 508                                                 switch ((string) enumerator.Key) {
 509                                                 case "":
 510                                                         Assert.IsNotNull (enumerator.Value, "#A1");
 511                                                         Assert.AreEqual ("BO", enumerator.Value, "#A2");
 512                                                         break;
 513                                                 case "Address":
 514                                                         Assert.IsNotNull (enumerator.Value, "#B1");
 515 #if NET_2_0
 516                                                         Assert.AreEqual (string.Empty, enumerator.Value, "#B2");
 517 #else
 518                                                         Assert.AreEqual ("Boston ", enumerator.Value, "#B2");
 519 #endif
 520                                                         break;
 521                                                 case "country":
 522                                                         Assert.IsNotNull (enumerator.Value, "#C1");
 523 #if NET_2_0
 524                                                         Assert.AreEqual (string.Empty, enumerator.Value, "#C2");
 525 #else
 526                                                         Assert.AreEqual ("Belgium", enumerator.Value, "#C2");
 527 #endif
 528                                                         break;
 529                                                 case "firstName":
 530 #if NET_2_0
 531                                                         Assert.IsNull (enumerator.Value, "#D");
 532 #else
 533                                                         Assert.IsNotNull (enumerator.Value, "#D1");
 534                                                         Assert.AreEqual (string.Empty, enumerator.Value, "#D2");
 535 #endif
 536                                                         break;
 537                                                 case "zip":
 538                                                         Assert.IsNotNull (enumerator.Value, "#E1");
 539                                                         Assert.AreEqual (" <3510> ", enumerator.Value, "#E2");
 540                                                         break;
 541                                                 default:
 542                                                         Assert.Fail ("#F:" + enumerator.Key);
 543                                                         break;
 544                                                 }
 545                                         }
 546                                         Assert.AreEqual (5, entries, "#G");
 547                                 }
 548                         }
 549                 }
 550
 551                 [Test]
 552                 public void ResHeader_Missing ()
 553                 {
 554                         const string resXTemplate =
 555                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
 556                                 "<root>" +
 557                                 "       <data name=\"name\">" +
 558                                 "               <value>de Icaza</value>" +
 559                                 "       </data>" +
 560                                 "       <data name=\"firstName\">" +
 561                                 "               <value />" +
 562                                 "       </data>" +
 563                                 "       <data name=\"address\" />" +
 564                                 "</root>";
 565
 566                         string resxFile = Path.Combine (_tempDirectory, "resources.resx");
 567                         using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
 568                                 sw.Write (resXTemplate);
 569                         }
 570
 571                         // Stream
 572                         using (FileStream fs = new FileStream (resxFile, FileMode.Open, FileAccess.Read, FileShare.Read)) {
 573                                 using (ResXResourceReader r = new ResXResourceReader (fs)) {
 574                                         try {
 575                                                 r.GetEnumerator ();
 576                                                 Assert.Fail ("#A1");
 577                                         } catch (ArgumentException ex) {
 578                                                 //Invalid ResX input.  Could not find valid \"resheader\"
 579                                                 // tags for the ResX reader & writer type names
 580                                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 581                                                 Assert.IsNull (ex.InnerException, "#A3");
 582                                                 Assert.IsNotNull (ex.Message, "#A4");
 583                                                 Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#A5");
 584                                                 Assert.IsNull (ex.ParamName, "#A6");
 585                                         }
 586                                 }
 587                         }
 588
 589                         // File
 590                         using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
 591                                 try {
 592                                         r.GetEnumerator ();
 593                                         Assert.Fail ("#B1");
 594                                 } catch (ArgumentException ex) {
 595                                         //Invalid ResX input.  Could not find valid \"resheader\"
 596                                         // tags for the ResX reader & writer type names
 597                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 598                                         Assert.IsNull (ex.InnerException, "#B3");
 599                                         Assert.IsNotNull (ex.Message, "#B4");
 600                                         Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#B5");
 601                                         Assert.IsNull (ex.ParamName, "#B6");
 602                                 }
 603                         }
 604
 605                         // TextReader
 606                         using (StreamReader sr = new StreamReader (resxFile, Encoding.UTF8)) {
 607                                 using (ResXResourceReader r = new ResXResourceReader (sr)) {
 608                                         try {
 609                                                 r.GetEnumerator ();
 610                                                 Assert.Fail ("#C1");
 611                                         } catch (ArgumentException ex) {
 612                                                 //Invalid ResX input.  Could not find valid \"resheader\"
 613                                                 // tags for the ResX reader & writer type names
 614                                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 615                                                 Assert.IsNull (ex.InnerException, "#C3");
 616                                                 Assert.IsNotNull (ex.Message, "#C4");
 617                                                 Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#C5");
 618                                                 Assert.IsNull (ex.ParamName, "#C6");
 619                                         }
 620                                 }
 621                         }
 622                 }
 623
 624                 [Test]
 625                 public void ResHeader_ResMimeType ()
 626                 {
 627                         const string resXTemplate =
 628                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
 629                                 "<root>" +
 630                                 "       <resheader name=\"resMIMEtype\">" +
 631                                 "               {0}" +
 632                                 "       </resheader>" +
 633                                 "       <resheader name=\"version\">" +
 634                                 "               <value>{1}</value>" +
 635                                 "       </resheader>" +
 636                                 "       <resheader name=\"reAder\">" +
 637                                 "               <value>System.Resources.ResXResourceReader, {2}</value>" +
 638                                 "       </resheader>" +
 639                                 "       <resheader name=\"wriTer\">" +
 640                                 "               <value>System.Resources.ResXResourceWriter, {2}</value>" +
 641                                 "       </resheader>" +
 642                                 "</root>";
 643
 644                         string resXContent = null;
 645
 646                         // <value> element, exact case
 647                         resXContent = string.Format (CultureInfo.InvariantCulture,
 648                                 resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
 649                                 Consts.AssemblySystem_Windows_Forms);
 650                         using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
 651                                 r.GetEnumerator ();
 652                         }
 653
 654                         // <value> element, uppercase
 655                         resXContent = string.Format (CultureInfo.InvariantCulture,
 656                                 resXTemplate, ResXResourceWriter.ResMimeType.ToUpper (), "1.0",
 657                                 Consts.AssemblySystem_Windows_Forms);
 658                         using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
 659                                 try {
 660                                         r.GetEnumerator ();
 661                                         Assert.Fail ("#A1");
 662                                 } catch (ArgumentException ex) {
 663                                         //Invalid ResX input.  Could not find valid \"resheader\"
 664                                         // tags for the ResX reader & writer type names
 665                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 666                                         Assert.IsNull (ex.InnerException, "#A3");
 667                                         Assert.IsNotNull (ex.Message, "#A4");
 668                                         Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#A5");
 669                                         Assert.IsNull (ex.ParamName, "#A6");
 670                                 }
 671                         }
 672
 673                         // text, exact case
 674                         resXContent = string.Format (CultureInfo.InvariantCulture,
 675                                 resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
 676                                 Consts.AssemblySystem_Windows_Forms);
 677                         using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
 678                                 r.GetEnumerator ();
 679                         }
 680
 681                         // text, uppercase
 682                         resXContent = string.Format (CultureInfo.InvariantCulture,
 683                                 resXTemplate, ResXResourceWriter.ResMimeType.ToUpper (), "1.0",
 684                                 Consts.AssemblySystem_Windows_Forms);
 685                         using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
 686                                 try {
 687                                         r.GetEnumerator ();
 688                                         Assert.Fail ("#B1");
 689                                 } catch (ArgumentException ex) {
 690                                         //Invalid ResX input.  Could not find valid \"resheader\"
 691                                         // tags for the ResX reader & writer type names
 692                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 693                                         Assert.IsNull (ex.InnerException, "#B3");
 694                                         Assert.IsNotNull (ex.Message, "#B4");
 695                                         Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#B5");
 696                                         Assert.IsNull (ex.ParamName, "#B6");
 697                                 }
 698                         }
 699
 700                         // CDATA, exact case
 701                         resXContent = string.Format (CultureInfo.InvariantCulture,
 702                                 resXTemplate, "<![CDATA[" +ResXResourceWriter.ResMimeType + "]]>",
 703                                 "1.0", Consts.AssemblySystem_Windows_Forms);
 704                         using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
 705                                 r.GetEnumerator ();
 706                         }
 707
 708                         // CDATA, uppercase
 709                         resXContent = string.Format (CultureInfo.InvariantCulture,
 710                                 resXTemplate, "<![CDATA[" + ResXResourceWriter.ResMimeType.ToUpper () + "]]>",
 711                                 "1.0", Consts.AssemblySystem_Windows_Forms);
 712                         using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
 713                                 try {
 714                                         r.GetEnumerator ();
 715                                         Assert.Fail ("#C1");
 716                                 } catch (ArgumentException ex) {
 717                                         //Invalid ResX input.  Could not find valid \"resheader\"
 718                                         // tags for the ResX reader & writer type names
 719                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 720                                         Assert.IsNull (ex.InnerException, "#C3");
 721                                         Assert.IsNotNull (ex.Message, "#C4");
 722                                         Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#C5");
 723                                         Assert.IsNull (ex.ParamName, "#C6");
 724                                 }
 725                         }
 726
 727                         // <whatever> element, exact case
 728                         resXContent = string.Format (CultureInfo.InvariantCulture,
 729                                 resXTemplate, "<whatever>" + ResXResourceWriter.ResMimeType + "</whatever>",
 730                                 "1.0", Consts.AssemblySystem_Windows_Forms);
 731                         using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
 732                                 r.GetEnumerator ();
 733                         }
 734
 735                         // <whatever> element, uppercase
 736                         resXContent = string.Format (CultureInfo.InvariantCulture,
 737                                 resXTemplate, "<whatever>" + ResXResourceWriter.ResMimeType.ToUpper () + "</whatever>",
 738                                 "1.0", Consts.AssemblySystem_Windows_Forms);
 739                         using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
 740                                 try {
 741                                         r.GetEnumerator ();
 742                                         Assert.Fail ("#D1");
 743                                 } catch (ArgumentException ex) {
 744                                         //Invalid ResX input.  Could not find valid \"resheader\"
 745                                         // tags for the ResX reader & writer type names
 746                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
 747                                         Assert.IsNull (ex.InnerException, "#D3");
 748                                         Assert.IsNotNull (ex.Message, "#D4");
 749                                         Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#D5");
 750                                         Assert.IsNull (ex.ParamName, "#D6");
 751                                 }
 752                         }
 753                 }
 754
 755                 [Test]
 756                 public void ResHeader_ResMimeType_Empty ()
 757                 {
 758                         const string resXTemplate =
 759                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
 760                                 "<root>" +
 761                                 "       <resheader name=\"resmimetype\"></resheader>" +
 762                                 "</root>";
 763
 764                         using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXTemplate))) {
 765                                 try {
 766                                         r.GetEnumerator ();
 767                                         Assert.Fail ("#1");
 768                                 } catch (ArgumentException ex) {
 769                                         //Invalid ResX input.  Could not find valid \"resheader\"
 770                                         // tags for the ResX reader & writer type names
 771                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 772                                         Assert.IsNull (ex.InnerException, "#3");
 773                                         Assert.IsNotNull (ex.Message, "#4");
 774                                         Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#5");
 775                                         Assert.IsNull (ex.ParamName, "#6");
 776                                 }
 777                         }
 778                 }
 779
 780                 [Test]
 781                 public void ResHeader_ResMimeType_Invalid ()
 782                 {
 783                         const string resXTemplate =
 784                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
 785                                 "<root>" +
 786                                 "       <resheader name=\"resmimetype\">" +
 787                                 "               <value>{0}</value>" +
 788                                 "       </resheader>" +
 789                                 "       <resheader name=\"version\">" +
 790                                 "               <value>{1}</value>" +
 791                                 "       </resheader>" +
 792                                 "       <resheader name=\"reader\">" +
 793                                 "               <value>System.Resources.ResXResourceReader, {2}</value>" +
 794                                 "       </resheader>" +
 795                                 "       <resheader name=\"writer\">" +
 796                                 "               <value>System.Resources.ResXResourceWriter, {2}</value>" +
 797                                 "       </resheader>" +
 798                                 "       <data name=\"name\">" +
 799                                 "               <value>de Icaza</value>" +
 800                                 "       </data>" +
 801                                 "       <data name=\"firstName\">" +
 802                                 "               <value />" +
 803                                 "       </data>" +
 804                                 "       <data name=\"Address\" />" +
 805                                 "</root>";
 806
 807                         string resxFile = Path.Combine (_tempDirectory, "resources.resx");
 808                         using (StreamWriter sw = new StreamWriter (resxFile, false, Encoding.UTF8)) {
 809                                 sw.Write (string.Format (CultureInfo.InvariantCulture,
 810                                         resXTemplate, "notvalid", "1.0", Consts.AssemblySystem_Windows_Forms
 811                                         ));
 812                         }
 813
 814                         // Stream
 815                         using (FileStream fs = new FileStream (resxFile, FileMode.Open, FileAccess.Read, FileShare.Read)) {
 816                                 using (ResXResourceReader r = new ResXResourceReader (fs)) {
 817                                         try {
 818                                                 r.GetEnumerator ();
 819                                                 Assert.Fail ("#A1");
 820                                         } catch (ArgumentException ex) {
 821                                                 //Invalid ResX input.  Could not find valid \"resheader\"
 822                                                 // tags for the ResX reader & writer type names
 823                                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
 824                                                 Assert.IsNull (ex.InnerException, "#A3");
 825                                                 Assert.IsNotNull (ex.Message, "#A4");
 826                                                 Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#A5");
 827                                                 Assert.IsNull (ex.ParamName, "#A6");
 828                                         }
 829                                 }
 830                         }
 831
 832                         // File
 833                         using (ResXResourceReader r = new ResXResourceReader (resxFile)) {
 834                                 try {
 835                                         r.GetEnumerator ();
 836                                         Assert.Fail ("#B1");
 837                                 } catch (ArgumentException ex) {
 838                                         //Invalid ResX input.  Could not find valid \"resheader\"
 839                                         // tags for the ResX reader & writer type names
 840                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 841                                         Assert.IsNull (ex.InnerException, "#B3");
 842                                         Assert.IsNotNull (ex.Message, "#B4");
 843                                         Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#B5");
 844                                         Assert.IsNull (ex.ParamName, "#B6");
 845                                 }
 846                         }
 847
 848                         // TextReader
 849                         using (StreamReader sr = new StreamReader (resxFile, Encoding.UTF8)) {
 850                                 using (ResXResourceReader r = new ResXResourceReader (sr)) {
 851                                         try {
 852                                                 r.GetEnumerator ();
 853                                                 Assert.Fail ("#C1");
 854                                         } catch (ArgumentException ex) {
 855                                                 //Invalid ResX input.  Could not find valid \"resheader\"
 856                                                 // tags for the ResX reader & writer type names
 857                                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 858                                                 Assert.IsNull (ex.InnerException, "#C3");
 859                                                 Assert.IsNotNull (ex.Message, "#C4");
 860                                                 Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#C5");
 861                                                 Assert.IsNull (ex.ParamName, "#C6");
 862                                         }
 863                                 }
 864                         }
 865                 }
 866
 867                 [Test]
 868                 public void ResHeader_ResMimeType_Null ()
 869                 {
 870                         const string resXTemplate =
 871                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
 872                                 "<root>" +
 873                                 "       <resheader name=\"resmimetype\" />" +
 874                                 "</root>";
 875
 876                         using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXTemplate))) {
 877                                 try {
 878                                         r.GetEnumerator ();
 879                                         Assert.Fail ("#1");
 880                                 } catch (ArgumentException ex) {
 881                                         //Invalid ResX input.  Could not find valid \"resheader\"
 882                                         // tags for the ResX reader & writer type names
 883                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 884                                         Assert.IsNull (ex.InnerException, "#3");
 885                                         Assert.IsNotNull (ex.Message, "#4");
 886                                         Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#5");
 887                                         Assert.IsNull (ex.ParamName, "#6");
 888                                 }
 889                         }
 890                 }
 891
 892                 [Test]
 893                 public void ResHeader_Reader_Invalid ()
 894                 {
 895                         const string resXTemplate =
 896                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
 897                                 "<root>" +
 898                                 "       <resheader name=\"resmimetype\">" +
 899                                 "               {0}" +
 900                                 "       </resheader>" +
 901                                 "       <resheader name=\"version\">" +
 902                                 "               <value>{1}</value>" +
 903                                 "       </resheader>" +
 904                                 "       <resheader name=\"reader\">" +
 905                                 "               <value>System.Resources.InvalidResXResourceReader, {2}</value>" +
 906                                 "       </resheader>" +
 907                                 "       <resheader name=\"writer\">" +
 908                                 "               <value>System.Resources.ResXResourceWriter, {2}</value>" +
 909                                 "       </resheader>" +
 910                                 "</root>";
 911
 912                         string resXContent = string.Format (CultureInfo.InvariantCulture,
 913                                 resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
 914                                 Consts.AssemblySystem_Windows_Forms);
 915                         using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
 916                                 try {
 917                                         r.GetEnumerator ();
 918                                         Assert.Fail ("#1");
 919                                 } catch (ArgumentException ex) {
 920                                         //Invalid ResX input.  Could not find valid \"resheader\"
 921                                         // tags for the ResX reader & writer type names
 922                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 923                                         Assert.IsNull (ex.InnerException, "#3");
 924                                         Assert.IsNotNull (ex.Message, "#4");
 925                                         Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#5");
 926                                         Assert.IsNull (ex.ParamName, "#6");
 927                                 }
 928                         }
 929                 }
 930
 931                 [Test]
 932                 public void ResHeader_Reader_Missing ()
 933                 {
 934                         const string resXTemplate =
 935                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
 936                                 "<root>" +
 937                                 "       <resheader name=\"resmimetype\">" +
 938                                 "               {0}" +
 939                                 "       </resheader>" +
 940                                 "       <resheader name=\"version\">" +
 941                                 "               <value>{1}</value>" +
 942                                 "       </resheader>" +
 943                                 "       <resheader name=\"writer\">" +
 944                                 "               <value>System.Resources.ResXResourceWriter, {2}</value>" +
 945                                 "       </resheader>" +
 946                                 "</root>";
 947
 948                         string resXContent = string.Format (CultureInfo.InvariantCulture,
 949                                 resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
 950                                 Consts.AssemblySystem_Windows_Forms);
 951                         using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
 952                                 try {
 953                                         r.GetEnumerator ();
 954                                         Assert.Fail ("#1");
 955                                 } catch (ArgumentException ex) {
 956                                         //Invalid ResX input.  Could not find valid \"resheader\"
 957                                         // tags for the ResX reader & writer type names
 958                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 959                                         Assert.IsNull (ex.InnerException, "#3");
 960                                         Assert.IsNotNull (ex.Message, "#4");
 961                                         Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#5");
 962                                         Assert.IsNull (ex.ParamName, "#6");
 963                                 }
 964                         }
 965                 }
 966
 967                 [Test]
 968                 public void ResHeader_Reader_Null ()
 969                 {
 970                         const string resXTemplate =
 971                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
 972                                 "<root>" +
 973                                 "       <resheader name=\"resmimetype\">" +
 974                                 "               {0}" +
 975                                 "       </resheader>" +
 976                                 "       <resheader name=\"version\">" +
 977                                 "               <value>{1}</value>" +
 978                                 "       </resheader>" +
 979                                 "       <resheader name=\"reader\" />" +
 980                                 "       <resheader name=\"writer\">" +
 981                                 "               <value>System.Resources.ResXResourceWriter, {2}</value>" +
 982                                 "       </resheader>" +
 983                                 "</root>";
 984
 985                         string resXContent = string.Format (CultureInfo.InvariantCulture,
 986                                 resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
 987                                 Consts.AssemblySystem_Windows_Forms);
 988                         using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
 989                                 try {
 990                                         r.GetEnumerator ();
 991                                         Assert.Fail ("#1");
 992                                 } catch (ArgumentException ex) {
 993                                         //Invalid ResX input.  Could not find valid \"resheader\"
 994                                         // tags for the ResX reader & writer type names
 995                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 996                                         Assert.IsNull (ex.InnerException, "#3");
 997                                         Assert.IsNotNull (ex.Message, "#4");
 998                                         Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#5");
 999                                         Assert.IsNull (ex.ParamName, "#6");
1000                                 }
1001                         }
1002                 }
1003
1004                 [Test]
1005                 public void ResHeader_Writer_Invalid ()
1006                 {
1007                         const string resXTemplate =
1008                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
1009                                 "<root>" +
1010                                 "       <resheader name=\"resmimetype\">" +
1011                                 "               {0}" +
1012                                 "       </resheader>" +
1013                                 "       <resheader name=\"version\">" +
1014                                 "               <value>{1}</value>" +
1015                                 "       </resheader>" +
1016                                 "       <resheader name=\"reader\">" +
1017                                 "               <value>System.Resources.ResXResourceReader, {2}</value>" +
1018                                 "       </resheader>" +
1019                                 "       <resheader name=\"writer\">" +
1020                                 "               <value>System.Resources.InvalidResXResourceWriter, {2}</value>" +
1021                                 "       </resheader>" +
1022                                 "</root>";
1023
1024                         string resXContent = string.Format (CultureInfo.InvariantCulture,
1025                                 resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
1026                                 Consts.AssemblySystem_Windows_Forms);
1027                         using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
1028                                 try {
1029                                         r.GetEnumerator ();
1030                                         Assert.Fail ("#1");
1031                                 } catch (ArgumentException ex) {
1032                                         //Invalid ResX input.  Could not find valid \"resheader\"
1033                                         // tags for the ResX reader & writer type names
1034                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1035                                         Assert.IsNull (ex.InnerException, "#3");
1036                                         Assert.IsNotNull (ex.Message, "#4");
1037                                         Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#5");
1038                                         Assert.IsNull (ex.ParamName, "#6");
1039                                 }
1040                         }
1041                 }
1042
1043                 [Test]
1044                 public void ResHeader_Writer_Missing ()
1045                 {
1046                         const string resXTemplate =
1047                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
1048                                 "<root>" +
1049                                 "       <resheader name=\"resmimetype\">" +
1050                                 "               {0}" +
1051                                 "       </resheader>" +
1052                                 "       <resheader name=\"version\">" +
1053                                 "               <value>{1}</value>" +
1054                                 "       </resheader>" +
1055                                 "       <resheader name=\"reader\">" +
1056                                 "               <value>System.Resources.ResXResourceReader, {2}</value>" +
1057                                 "       </resheader>" +
1058                                 "</root>";
1059
1060                         string resXContent = string.Format (CultureInfo.InvariantCulture,
1061                                 resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
1062                                 Consts.AssemblySystem_Windows_Forms);
1063                         using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
1064                                 try {
1065                                         r.GetEnumerator ();
1066                                         Assert.Fail ("#1");
1067                                 } catch (ArgumentException ex) {
1068                                         //Invalid ResX input.  Could not find valid \"resheader\"
1069                                         // tags for the ResX reader & writer type names
1070                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1071                                         Assert.IsNull (ex.InnerException, "#3");
1072                                         Assert.IsNotNull (ex.Message, "#4");
1073                                         Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#5");
1074                                         Assert.IsNull (ex.ParamName, "#6");
1075                                 }
1076                         }
1077                 }
1078
1079                 [Test]
1080                 public void ResHeader_Writer_Null ()
1081                 {
1082                         const string resXTemplate =
1083                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
1084                                 "<root>" +
1085                                 "       <resheader name=\"resmimetype\">" +
1086                                 "               {0}" +
1087                                 "       </resheader>" +
1088                                 "       <resheader name=\"version\">" +
1089                                 "               <value>{1}</value>" +
1090                                 "       </resheader>" +
1091                                 "       <resheader name=\"reader\">" +
1092                                 "               <value>System.Resources.ResXResourceReader, {2}</value>" +
1093                                 "       </resheader>" +
1094                                 "       <resheader name=\"writer\" />" +
1095                                 "</root>";
1096
1097                         string resXContent = string.Format (CultureInfo.InvariantCulture,
1098                                 resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
1099                                 Consts.AssemblySystem_Windows_Forms);
1100                         using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
1101                                 try {
1102                                         r.GetEnumerator ();
1103                                         Assert.Fail ("#1");
1104                                 } catch (ArgumentException ex) {
1105                                         //Invalid ResX input.  Could not find valid \"resheader\"
1106                                         // tags for the ResX reader & writer type names
1107                                         Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1108                                         Assert.IsNull (ex.InnerException, "#3");
1109                                         Assert.IsNotNull (ex.Message, "#4");
1110                                         Assert.IsTrue (ex.Message.IndexOf ("\"resheader\"") != -1, "#5");
1111                                         Assert.IsNull (ex.ParamName, "#6");
1112                                 }
1113                         }
1114                 }
1115
1116                 [Test]
1117                 public void ResHeader_Unknown ()
1118                 {
1119                         const string resXTemplate =
1120                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
1121                                 "<root>" +
1122                                 "       <resheader name=\"resmimetype\">" +
1123                                 "               {0}" +
1124                                 "       </resheader>" +
1125                                 "       <resheader name=\"version\">" +
1126                                 "               <value>{1}</value>" +
1127                                 "       </resheader>" +
1128                                 "       <resheader name=\"reader\">" +
1129                                 "               <value>  System.Resources.ResXResourceReader  , {2}</value>" +
1130                                 "       </resheader>" +
1131                                 "       <resheader name=\"writer\">" +
1132                                 "               <value>  System.Resources.ResXResourceWriter  , {2}</value>" +
1133                                 "       </resheader>" +
1134                                 "       <resheader name=\"UNKNOWN\">" +
1135                                 "               <value>whatever</value>" +
1136                                 "       </resheader>" +
1137                                 "</root>";
1138
1139                         string resXContent = string.Format (CultureInfo.InvariantCulture,
1140                                 resXTemplate, ResXResourceWriter.ResMimeType, "1.0",
1141                                 Consts.AssemblySystem_Windows_Forms);
1142                         using (ResXResourceReader r = new ResXResourceReader (new StringReader (resXContent))) {
1143                                 r.GetEnumerator ();
1144                         }
1145                 }
1146
1147                 [Test]
1148                 public void ResName_Null ()
1149                 {
1150                         const string resXContent =
1151                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
1152                                 "<root>" +
1153                                 "       <resheader name=\"resmimetype\">" +
1154                                 "               <value>invalid</value>" +
1155                                 "       </resheader>" +
1156                                 "       <data name=\"name\">" +
1157                                 "               <value>de Icaza</value>" +
1158                                 "       </data>" +
1159                                 "       <data>" +
1160                                 "               <value>whatever</value>" +
1161                                 "       </data>" +
1162                                 "</root>";
1163
1164                         using (StringReader sr = new StringReader (resXContent)) {
1165                                 using (ResXResourceReader r = new ResXResourceReader (sr)) {
1166                                         try {
1167                                                 r.GetEnumerator ();
1168                                                 Assert.Fail ("#1");
1169                                         } catch (ArgumentException ex) {
1170                                                 // Invalid ResX input.
1171                                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
1172                                                 Assert.IsNotNull (ex.InnerException, "#3");
1173                                                 Assert.IsNotNull (ex.Message, "#4");
1174                                                 Assert.IsNull (ex.ParamName, "#5");
1175
1176 #if NET_2_0
1177                                                 // Could not find a name for a resource. The resource
1178                                                 // value was 'whatever'. Line 1, position 200
1179                                                 XmlException inner = ex.InnerException as XmlException;
1180                                                 Assert.IsNotNull (inner, "#6");
1181                                                 Assert.AreEqual (typeof (XmlException), inner.GetType (), "#7");
1182                                                 Assert.IsNotNull (inner.InnerException, "#8");
1183                                                 Assert.AreEqual (1, inner.LineNumber, "#9");
1184                                                 Assert.AreEqual (200, inner.LinePosition, "#10");
1185                                                 Assert.IsNotNull (inner.Message, "#11");
1186                                                 Assert.IsTrue (inner.Message.IndexOf ("'whatever'") != -1, "#12");
1187                                                 Assert.IsTrue (inner.Message.IndexOf (" 1") != -1, "#13");
1188                                                 Assert.IsTrue (inner.Message.IndexOf ("200") != -1, "#14");
1189
1190                                                 // Could not find a name for a resource. The resource
1191                                                 // value was 'whatever'
1192                                                 ArgumentException inner2 = inner.InnerException as ArgumentException;
1193                                                 Assert.IsNotNull (inner2, "#15");
1194                                                 Assert.AreEqual (typeof (ArgumentException), inner2.GetType (), "#16");
1195                                                 Assert.IsNull (inner2.InnerException, "#17");
1196                                                 Assert.IsNotNull (inner2.Message, "#18");
1197                                                 Assert.IsTrue (inner2.Message.IndexOf ("'whatever'") != -1, "#19");
1198                                                 Assert.IsNull (inner2.ParamName, "#20");
1199 #else
1200                                                 // Could not find a name for a resource. The resource
1201                                                 // value was 'whatever'
1202                                                 ArgumentException inner = ex.InnerException as ArgumentException;
1203                                                 Assert.IsNotNull (inner, "#6");
1204                                                 Assert.AreEqual (typeof (ArgumentException), inner.GetType (), "#7");
1205                                                 Assert.IsNull (inner.InnerException, "#8");
1206                                                 Assert.IsNotNull (inner.Message, "#9");
1207                                                 Assert.IsTrue (inner.Message.IndexOf ("'whatever'") != -1, "#10");
1208                                                 Assert.IsNull (inner.ParamName, "#11");
1209 #endif
1210                                         }
1211                                 }
1212                         }
1213                 }
1214
1215                 [Test]
1216                 public void ResValue ()
1217                 {
1218                         string resXContent = string.Format (CultureInfo.CurrentCulture,
1219                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
1220                                 "<root>" +
1221                                 "       <resheader name=\"resmimetype\">" +
1222                                 "               <value>{0}</value>" +
1223                                 "       </resheader>" +
1224                                 "       <resheader name=\"reader\">" +
1225                                 "               <value>System.Resources.ResXResourceReader, {1}</value>" +
1226                                 "       </resheader>" +
1227                                 "       <resheader name=\"writer\">" +
1228                                 "               <value>System.Resources.ResXResourceWriter, {1}</value>" +
1229                                 "       </resheader>" +
1230                                 "       <data name=\"name1\">" +
1231                                 "               <value><![CDATA[ <value1> ]]></value>" +
1232                                 "       </data>" +
1233                                 "       <data name=\"name2\">" +
1234                                 "               <value>  <![CDATA[<value2>]]>  </value>" +
1235                                 "       </data>" +
1236                                 "       <data name=\"name3\">" +
1237                                 "                 <![CDATA[<value3>]]>  " +
1238                                 "       </data>" +
1239                                 "       <data name=\"name4\">" +
1240                                 "               <value> value4 </value>" +
1241                                 "       </data>" +
1242                                 "       <data name=\"name5\">" +
1243                                 "               test<value>value5</value>" +
1244                                 "       </data>" +
1245                                 "       <data name=\"name6\">" +
1246                                 "               test1<value>value6</value>test2" +
1247                                 "       </data>" +
1248                                 "       <data name=\"name7\">" +
1249                                 "               <value>value7a</value>" +
1250                                 "               <whatever>value7b</whatever>" +
1251                                 "       </data>" +
1252                                 "       <data name=\"name8\">" +
1253                                 "               <whatever>value8</whatever>" +
1254                                 "       </data>" +
1255                                 "       <data name=\"name9\">" +
1256                                 "               <whatever>value9a</whatever>" +
1257                                 "               <whatever>value9b</whatever>" +
1258                                 "       </data>" +
1259                                 "       <data name=\"name10\">" +
1260                                 "               test<whatever>value10</whatever>" +
1261                                 "       </data>" +
1262                                 "       <data name=\"name11\">" +
1263                                 "               test1<whatever>value11</whatever>test2" +
1264                                 "       </data>" +
1265                                 "       <data name=\"name12\">" +
1266                                 "               <value> test  <![CDATA[<value12>]]>  </value>" +
1267                                 "       </data>" +
1268                                 "       <data name=\"name13\">" +
1269                                 "                test <![CDATA[<value13>]]>  " +
1270                                 "       </data>" +
1271                                 "       <data name=\"name14\" />" +
1272                                 "       <data name=\"name15\"></data>" +
1273                                 "       <data name=\"name16\">value16</data>" +
1274                                 "       <data name=\"name17\">value17</data>" +
1275                                 "       <data name=\"name18\">" +
1276                                 "               <value>value18</value>" +
1277                                 "               <data name=\"name19\">" +
1278                                 "                       <value>value18</value>" +
1279                                 "               </data>" +
1280                                 "       </data>" +
1281                                 "</root>",
1282                                 ResXResourceWriter.ResMimeType, Consts.AssemblySystem_Windows_Forms);
1283
1284                         using (StringReader sr = new StringReader (resXContent)) {
1285                                 using (ResXResourceReader r = new ResXResourceReader (sr)) {
1286
1287                                         IDictionaryEnumerator enumerator = r.GetEnumerator ();
1288                                         int entries = 0;
1289                                         while (enumerator.MoveNext ()) {
1290                                                 entries++;
1291                                                 switch ((string) enumerator.Key) {
1292                                                 case "name1":
1293                                                         Assert.IsNotNull (enumerator.Value, "#A1");
1294                                                         Assert.AreEqual (" <value1> ", enumerator.Value, "#A2");
1295                                                         break;
1296                                                 case "name2":
1297                                                         Assert.IsNotNull (enumerator.Value, "#B1");
1298                                                         Assert.AreEqual ("<value2>", enumerator.Value, "#B2");
1299                                                         break;
1300                                                 case "name3":
1301                                                         Assert.IsNotNull (enumerator.Value, "#C1");
1302                                                         Assert.AreEqual ("<value3>", enumerator.Value, "#C2");
1303                                                         break;
1304                                                 case "name4":
1305                                                         Assert.IsNotNull (enumerator.Value, "#D1");
1306                                                         Assert.AreEqual (" value4 ", enumerator.Value, "#D2");
1307                                                         break;
1308                                                 case "name5":
1309                                                         Assert.IsNotNull (enumerator.Value, "#E1");
1310 #if NET_2_0
1311                                                         Assert.AreEqual ("value5", enumerator.Value, "#E2");
1312 #else
1313                                                         Assert.AreEqual ("test", enumerator.Value, "#E2");
1314 #endif
1315                                                         break;
1316                                                 case "name6":
1317                                                         Assert.IsNotNull (enumerator.Value, "#F1");
1318 #if NET_2_0
1319                                                         Assert.AreEqual ("test2", enumerator.Value, "#F2");
1320 #else
1321                                                         Assert.AreEqual ("test1", enumerator.Value, "#F2");
1322 #endif
1323                                                         break;
1324                                                 case "name7":
1325                                                         Assert.IsNotNull (enumerator.Value, "#G1");
1326 #if NET_2_0
1327                                                         Assert.AreEqual (string.Empty, enumerator.Value, "#G2");
1328 #else
1329                                                         Assert.AreEqual ("value7a", enumerator.Value, "#G2");
1330 #endif
1331                                                         break;
1332                                                 case "name8":
1333                                                         Assert.IsNotNull (enumerator.Value, "#H1");
1334 #if NET_2_0
1335                                                         Assert.AreEqual (string.Empty, enumerator.Value, "#H2");
1336 #else
1337                                                         Assert.AreEqual ("value8", enumerator.Value, "#H2");
1338 #endif
1339                                                         break;
1340                                                 case "name9":
1341                                                         Assert.IsNotNull (enumerator.Value, "#I1");
1342 #if NET_2_0
1343                                                         Assert.AreEqual (string.Empty, enumerator.Value, "#I2");
1344 #else
1345                                                         Assert.AreEqual ("value9a", enumerator.Value, "#I2");
1346 #endif
1347                                                         break;
1348                                                 case "name10":
1349                                                         Assert.IsNotNull (enumerator.Value, "#J1");
1350 #if NET_2_0
1351                                                         Assert.AreEqual (string.Empty, enumerator.Value, "#J2");
1352 #else
1353                                                         Assert.AreEqual ("test", enumerator.Value, "#J2");
1354 #endif
1355                                                         break;
1356                                                 case "name11":
1357                                                         Assert.IsNotNull (enumerator.Value, "#K1");
1358 #if NET_2_0
1359                                                         Assert.AreEqual ("test2", enumerator.Value, "#K2");
1360 #else
1361                                                         Assert.AreEqual ("test1", enumerator.Value, "#K2");
1362 #endif
1363                                                         break;
1364                                                 case "name12":
1365                                                         Assert.IsNotNull (enumerator.Value, "#L1");
1366                                                         Assert.AreEqual (" test  <value12>", enumerator.Value, "#L2");
1367                                                         break;
1368                                                 case "name13":
1369                                                         Assert.IsNotNull (enumerator.Value, "#M1");
1370 #if NET_2_0
1371                                                         Assert.AreEqual ("<value13>", enumerator.Value, "#M2");
1372 #else
1373                                                         Assert.AreEqual ("test", enumerator.Value, "#M2");
1374 #endif
1375                                                         break;
1376                                                 case "name14":
1377 #if NET_2_0
1378                                                         Assert.IsNull (enumerator.Value, "#N1");
1379 #else
1380                                                         Assert.IsNotNull (enumerator.Value, "#N1");
1381                                                         Assert.AreEqual (string.Empty, enumerator.Value, "#N2");
1382 #endif
1383                                                         break;
1384 #if NET_2_0
1385                                                 case "name16":
1386                                                         Assert.IsNotNull (enumerator.Value, "#O1");
1387                                                         Assert.AreEqual ("value16", enumerator.Value, "#O2");
1388                                                         break;
1389 #endif
1390                                                 case "name17":
1391                                                         Assert.IsNotNull (enumerator.Value, "#P1");
1392                                                         Assert.AreEqual ("value17", enumerator.Value, "#P2");
1393                                                         break;
1394                                                 case "name18":
1395                                                         Assert.IsNotNull (enumerator.Value, "#Q1");
1396                                                         Assert.AreEqual ("value18", enumerator.Value, "#Q2");
1397                                                         break;
1398                                                 default:
1399                                                         Assert.Fail ("#Q:" + enumerator.Key);
1400                                                         break;
1401                                                 }
1402                                         }
1403 #if NET_2_0
1404                                         Assert.AreEqual (17, entries, "#Q");
1405 #else
1406                                         Assert.AreEqual (16, entries, "#Q");
1407 #endif
1408                                 }
1409                         }
1410                 }
1411
1412                 private const string _resXFileRefTemplate =
1413                         "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
1414                         "<root>" +
1415                         "       <resheader name=\"resmimetype\">" +
1416                         "               <value>{0}</value>" +
1417                         "       </resheader>" +
1418                         "       <resheader name=\"version\">" +
1419                         "               <value>{1}</value>" +
1420                         "       </resheader>" +
1421                         "       <resheader name=\"reader\">" +
1422                         "               <value>System.Resources.ResXResourceReader, {2}</value>" +
1423                         "       </resheader>" +
1424                         "       <resheader name=\"writer\">" +
1425                         "               <value>System.Resources.ResXResourceWriter, {2}</value>" +
1426                         "       </resheader>" +
1427                         "       <data name=\"foo\" type=\"System.Resources.ResXFileRef, {2}\">" +
1428                         "               <value>{3};{4}{5}</value>" +
1429                         "       </data>" +
1430                         "</root>";
1431         }
1432 }