mcs/class/corlib/Test/System.Resources/ResourceManagerTest.cs

   1 //
   2 // ResourceManager.cs:
   3 //     NUnit Test Cases for System.Resources.ResourceManager
   4 //
   5 // Authors:
   6 //      Robert Jordan (robertj@gmx.net)
   7 //      Gert Driesen (drieseng@users.sourceforge.net)
   8 //      Sebastien Pouliot  <sebastien@ximian.com>
   9 //
  10 // Copyright (C) 2005,2008 Novell, Inc. (http://www.novell.com)
  11 //
  12
  13 //
  14 // Permission is hereby granted, free of charge, to any person obtaining
  15 // a copy of this software and associated documentation files (the
  16 // "Software"), to deal in the Software without restriction, including
  17 // without limitation the rights to use, copy, modify, merge, publish,
  18 // distribute, sublicense, and/or sell copies of the Software, and to
  19 // permit persons to whom the Software is furnished to do so, subject to
  20 // the following conditions:
  21 //
  22 // The above copyright notice and this permission notice shall be
  23 // included in all copies or substantial portions of the Software.
  24 //
  25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  29 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  30 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  31 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  32 //
  33
  34 using System;
  35 using System.Collections;
  36 using System.Globalization;
  37 using System.Reflection;
  38 using System.Resources;
  39 using System.Threading;
  40 using System.IO;
  41
  42 using NUnit.Framework;
  43
  44 namespace MonoTests.System.Resources
  45 {
  46         class ResourceManagerPoker : ResourceManager
  47         {
  48                 public ResourceManagerPoker ()
  49                 {
  50                         BaseNameField = String.Format ("Test{0}resources{0}MyResources", Path.DirectorySeparatorChar);
  51                 }
  52
  53                 public Hashtable GetResourceSets ()
  54                 {
  55                         return base.ResourceSets;
  56                 }
  57
  58                 public void InitResourceSets ()
  59                 {
  60                         base.ResourceSets = new Hashtable ();
  61                 }
  62         }
  63
  64         [TestFixture]
  65         public class ResourceManagerTest
  66         {
  67                 private CultureInfo _orgUICulture;
  68
  69                 [SetUp]
  70                 public void SetUp ()
  71                 {
  72                         _orgUICulture = Thread.CurrentThread.CurrentUICulture;
  73                 }
  74
  75                 [TearDown]
  76                 public void TearDown ()
  77                 {
  78                         Thread.CurrentThread.CurrentUICulture = _orgUICulture;
  79                 }
  80
  81                 [Test] // ResourceManager ()
  82                 public void Constructor0 ()
  83                 {
  84                         MockResourceManager rm = new MockResourceManager ();
  85                         Assert.IsNull (rm.BaseName, "#1");
  86                         Assert.IsNull (rm.BaseNameField, "#2");
  87                         Assert.IsFalse (rm.IgnoreCase, "#3");
  88                         Assert.IsNull (rm.MainAssembly, "#4");
  89                         Assert.IsNull (rm.ResourceSets, "#5");
  90                         Assert.IsNotNull (rm.ResourceSetType, "#6");
  91                         Assert.IsTrue (typeof (ResourceSet).IsAssignableFrom (rm.ResourceSetType), "#7");
  92                         Assert.IsFalse (typeof (ResourceSet) == rm.ResourceSetType, "#8");
  93                 }
  94
  95                 [Test] // ResourceManager (Type)
  96                 public void Constructor1 ()
  97                 {
  98                         MockResourceManager rm = new MockResourceManager (typeof (string));
  99                         Assert.IsNotNull (rm.BaseName, "#1");
 100                         Assert.AreEqual ("String", rm.BaseName, "#2");
 101                         Assert.IsNotNull (rm.BaseNameField, "#3");
 102                         Assert.AreEqual ("String", rm.BaseNameField, "#4");
 103                         Assert.IsFalse (rm.IgnoreCase, "#5");
 104                         Assert.IsNotNull (rm.MainAssembly, "#6");
 105                         Assert.AreEqual (typeof (String).Assembly, rm.MainAssembly, "#7");
 106                         Assert.IsNotNull (rm.ResourceSets, "#8");
 107                         Assert.AreEqual (0, rm.ResourceSets.Count, "#9");
 108                         Assert.IsNotNull (rm.ResourceSetType, "#10");
 109                         Assert.IsTrue (typeof (ResourceSet).IsAssignableFrom (rm.ResourceSetType), "#11");
 110                         Assert.IsFalse (typeof (ResourceSet) == rm.ResourceSetType, "#12");
 111                         Assert.AreEqual ("RuntimeResourceSet", rm.ResourceSetType.Name, "#13");
 112                 }
 113
 114                 [Test] // ResourceManager (Type)
 115                 public void Constructor1_ResourceSource_Null ()
 116                 {
 117                         try {
 118                                 new ResourceManager ((Type) null);
 119                                 Assert.Fail ("#1");
 120                         } catch (ArgumentNullException ex) {
 121                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 122                                 Assert.IsNull (ex.InnerException, "#3");
 123                                 Assert.IsNotNull (ex.Message, "#4");
 124                                 Assert.IsNotNull (ex.ParamName, "#5");
 125                                 Assert.AreEqual ("resourceSource", ex.ParamName, "#6");
 126                         }
 127                 }
 128
 129                 [Test] // ResourceManager (String, Assembly)
 130                 public void Constructor2 ()
 131                 {
 132                         MockResourceManager rm = null;
 133                         Assembly assembly = null;
 134
 135                         assembly = Assembly.GetExecutingAssembly ();
 136                         rm = new MockResourceManager ("mono", assembly);
 137                         Assert.IsNotNull (rm.BaseName, "#A1");
 138                         Assert.AreEqual ("mono", rm.BaseName, "#A2");
 139                         Assert.IsNotNull (rm.BaseNameField, "#A3");
 140                         Assert.AreEqual ("mono", rm.BaseNameField, "#A4");
 141                         Assert.IsFalse (rm.IgnoreCase, "#A5");
 142                         Assert.IsNotNull (rm.MainAssembly, "#A6");
 143                         Assert.AreEqual (assembly, rm.MainAssembly, "#A7");
 144                         Assert.IsNotNull (rm.ResourceSets, "#A8");
 145                         Assert.AreEqual (0, rm.ResourceSets.Count, "#A9");
 146                         Assert.IsNotNull (rm.ResourceSetType, "#A10");
 147                         Assert.IsTrue (typeof (ResourceSet).IsAssignableFrom (rm.ResourceSetType), "#A11");
 148                         Assert.IsFalse (typeof (ResourceSet) == rm.ResourceSetType, "#A12");
 149                         Assert.AreEqual ("RuntimeResourceSet", rm.ResourceSetType.Name, "#A13");
 150
 151                         assembly = typeof (int).Assembly;
 152                         rm = new MockResourceManager (string.Empty, assembly);
 153                         Assert.IsNotNull (rm.BaseName, "#B1");
 154                         Assert.AreEqual (string.Empty, rm.BaseName, "#B2");
 155                         Assert.IsNotNull (rm.BaseNameField, "#B3");
 156                         Assert.AreEqual (string.Empty, rm.BaseNameField, "#B4");
 157                         Assert.IsFalse (rm.IgnoreCase, "#B5");
 158                         Assert.IsNotNull (rm.MainAssembly, "#B6");
 159                         Assert.AreEqual (assembly, rm.MainAssembly, "#B7");
 160                         Assert.IsNotNull (rm.ResourceSets, "#B8");
 161                         Assert.AreEqual (0, rm.ResourceSets.Count, "#B9");
 162                         Assert.IsNotNull (rm.ResourceSetType, "#B10");
 163                         Assert.IsTrue (typeof (ResourceSet).IsAssignableFrom (rm.ResourceSetType), "#B11");
 164                         Assert.IsFalse (typeof (ResourceSet) == rm.ResourceSetType, "#B12");
 165                         Assert.AreEqual ("RuntimeResourceSet", rm.ResourceSetType.Name, "#B13");
 166                 }
 167
 168                 [Test] // ResourceManager (String, Assembly)
 169                 public void Constructor2_BaseName_Null ()
 170                 {
 171                         try {
 172                                 new ResourceManager ((string) null, Assembly.
 173                                         GetExecutingAssembly ());
 174                                 Assert.Fail ("#1");
 175                         } catch (ArgumentNullException ex) {
 176                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 177                                 Assert.IsNull (ex.InnerException, "#3");
 178                                 Assert.IsNotNull (ex.Message, "#4");
 179                                 Assert.IsNotNull (ex.ParamName, "#5");
 180                                 Assert.AreEqual ("baseName", ex.ParamName, "#6");
 181                         }
 182                 }
 183
 184                 [Test] // ResourceManager (String, Assembly)
 185                 public void Constructor2_BaseName_Resources ()
 186                 {
 187                         MockResourceManager rm = new MockResourceManager (
 188                                 "mono.resources",
 189                                 Assembly.GetExecutingAssembly ());
 190                         Assert.IsNotNull (rm.BaseName, "#1");
 191                         Assert.AreEqual ("mono.resources", rm.BaseName, "#2");
 192                         Assert.IsNotNull (rm.BaseNameField, "#3");
 193                         Assert.AreEqual ("mono.resources", rm.BaseNameField, "#4");
 194                         Assert.IsFalse (rm.IgnoreCase, "#5");
 195                         Assert.IsNotNull (rm.MainAssembly, "#6");
 196                         Assert.AreEqual (Assembly.GetExecutingAssembly (), rm.MainAssembly, "#7");
 197                         Assert.IsNotNull (rm.ResourceSets, "#8");
 198                         Assert.AreEqual (0, rm.ResourceSets.Count, "#9");
 199                         Assert.IsNotNull (rm.ResourceSetType, "#10");
 200                         Assert.IsTrue (typeof (ResourceSet).IsAssignableFrom (rm.ResourceSetType), "#11");
 201                         Assert.IsFalse (typeof (ResourceSet) == rm.ResourceSetType, "#12");
 202                         Assert.AreEqual ("RuntimeResourceSet", rm.ResourceSetType.Name, "#13");
 203                 }
 204
 205                 [Test] // ResourceManager (String, Assembly)
 206                 public void Constructor2_Assembly_Null ()
 207                 {
 208                         try {
 209                                 new ResourceManager (string.Empty, (Assembly) null);
 210                                 Assert.Fail ("#1");
 211                         } catch (ArgumentNullException ex) {
 212                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 213                                 Assert.IsNull (ex.InnerException, "#3");
 214                                 Assert.IsNotNull (ex.Message, "#4");
 215                                 Assert.IsNotNull (ex.ParamName, "#5");
 216                                 Assert.AreEqual ("assembly", ex.ParamName, "#6");
 217                         }
 218                 }
 219
 220                 [Test] // ResourceManager (String, Assembly, Type)
 221                 public void Constructor3 ()
 222                 {
 223                         MockResourceManager rm = null;
 224                         Assembly assembly = null;
 225
 226                         assembly = Assembly.GetExecutingAssembly ();
 227                         rm = new MockResourceManager ("mono", assembly,
 228                                 typeof (ResourceSet));
 229                         Assert.IsNotNull (rm.BaseName, "#A1");
 230                         Assert.AreEqual ("mono", rm.BaseName, "#A2");
 231                         Assert.IsNotNull (rm.BaseNameField, "#A3");
 232                         Assert.AreEqual ("mono", rm.BaseNameField, "#A4");
 233                         Assert.IsFalse (rm.IgnoreCase, "#A5");
 234                         Assert.IsNotNull (rm.MainAssembly, "#A6");
 235                         Assert.AreEqual (assembly, rm.MainAssembly, "#A7");
 236                         Assert.IsNotNull (rm.ResourceSets, "#A8");
 237                         Assert.AreEqual (0, rm.ResourceSets.Count, "#A9");
 238                         Assert.IsNotNull (rm.ResourceSetType, "#A10");
 239                         Assert.AreEqual (typeof (ResourceSet), rm.ResourceSetType, "#A11");
 240
 241                         assembly = typeof (int).Assembly;
 242                         rm = new MockResourceManager ("mono", assembly,
 243                                 typeof (MockResourceSet));
 244                         Assert.IsNotNull (rm.BaseName, "#B1");
 245                         Assert.AreEqual ("mono", rm.BaseName, "#B2");
 246                         Assert.IsNotNull (rm.BaseNameField, "#B3");
 247                         Assert.AreEqual ("mono", rm.BaseNameField, "#B4");
 248                         Assert.IsFalse (rm.IgnoreCase, "#B5");
 249                         Assert.IsNotNull (rm.MainAssembly, "#B6");
 250                         Assert.AreEqual (assembly, rm.MainAssembly, "#B7");
 251                         Assert.IsNotNull (rm.ResourceSets, "#B8");
 252                         Assert.AreEqual (0, rm.ResourceSets.Count, "#B9");
 253                         Assert.IsNotNull (rm.ResourceSetType, "#B10");
 254                         Assert.AreEqual (typeof (MockResourceSet), rm.ResourceSetType, "#B11");
 255                 }
 256
 257                 [Test] // ResourceManager (String, Assembly, Type)
 258                 public void Constructor3_BaseName_Null ()
 259                 {
 260                         try {
 261                                 new ResourceManager ((string) null, Assembly.
 262                                         GetExecutingAssembly (),
 263                                         typeof (ResourceSet));
 264                                 Assert.Fail ("#1");
 265                         } catch (ArgumentNullException ex) {
 266                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 267                                 Assert.IsNull (ex.InnerException, "#3");
 268                                 Assert.IsNotNull (ex.Message, "#4");
 269                                 Assert.IsNotNull (ex.ParamName, "#5");
 270                                 Assert.AreEqual ("baseName", ex.ParamName, "#6");
 271                         }
 272                 }
 273
 274                 [Test] // ResourceManager (String, Assembly, Type)
 275                 public void Constructor3_BaseName_Resources ()
 276                 {
 277                         MockResourceManager rm = new MockResourceManager (
 278                                 "mono.resources",
 279                                 Assembly.GetExecutingAssembly (),
 280                                 typeof (ResourceSet));
 281                         Assert.IsNotNull (rm.BaseName, "#1");
 282                         Assert.AreEqual ("mono.resources", rm.BaseName, "#2");
 283                         Assert.IsNotNull (rm.BaseNameField, "#3");
 284                         Assert.AreEqual ("mono.resources", rm.BaseNameField, "#4");
 285                         Assert.IsFalse (rm.IgnoreCase, "#5");
 286                         Assert.IsNotNull (rm.MainAssembly, "#6");
 287                         Assert.AreEqual (Assembly.GetExecutingAssembly (), rm.MainAssembly, "#7");
 288                         Assert.IsNotNull (rm.ResourceSets, "#8");
 289                         Assert.AreEqual (0, rm.ResourceSets.Count, "#9");
 290                         Assert.IsNotNull (rm.ResourceSetType, "#10");
 291                         Assert.AreEqual (typeof (ResourceSet), rm.ResourceSetType, "#11");
 292                 }
 293
 294                 [Test] // ResourceManager (String, Assembly, Type)
 295                 public void Constructor3_Assembly_Null ()
 296                 {
 297                         try {
 298                                 new ResourceManager (string.Empty, (Assembly) null,
 299                                         typeof (ResourceSet));
 300                                 Assert.Fail ("#1");
 301                         } catch (ArgumentNullException ex) {
 302                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 303                                 Assert.IsNull (ex.InnerException, "#3");
 304                                 Assert.IsNotNull (ex.Message, "#4");
 305                                 Assert.IsNotNull (ex.ParamName, "#5");
 306                                 Assert.AreEqual ("assembly", ex.ParamName, "#6");
 307                         }
 308                 }
 309
 310                 [Test] // ResourceManager (String, Assembly, Type)
 311                 public void Constructor3_UsingResourceSet_Invalid ()
 312                 {
 313                         try {
 314                                 new ResourceManager ("mono", typeof (int).Assembly,
 315                                         typeof (string));
 316                                 Assert.Fail ("#1");
 317                         } catch (ArgumentException ex) {
 318                                 // Type parameter must refer to a subclass of
 319                                 // ResourceSet
 320                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 321                                 Assert.IsNull (ex.InnerException, "#3");
 322                                 Assert.IsNotNull (ex.Message, "#4");
 323                                 Assert.IsTrue (ex.Message.IndexOf ("ResourceSet") != -1, "#5");
 324                                 Assert.IsNotNull (ex.ParamName, "#6");
 325                                 Assert.AreEqual ("usingResourceSet", ex.ParamName, "#7");
 326                         }
 327                 }
 328
 329                 [Test] // ResourceManager (String, Assembly, Type)
 330                 public void Constructor3_UsingResourceSet_Null ()
 331                 {
 332                         MockResourceManager rm = new MockResourceManager (
 333                                 string.Empty, Assembly.GetExecutingAssembly (),
 334                                 (Type) null);
 335                         Assert.IsNotNull (rm.BaseName, "#1");
 336                         Assert.AreEqual (string.Empty, rm.BaseName, "#2");
 337                         Assert.IsNotNull (rm.BaseNameField, "#3");
 338                         Assert.AreEqual (string.Empty, rm.BaseNameField, "#4");
 339                         Assert.IsFalse (rm.IgnoreCase, "#5");
 340                         Assert.IsNotNull (rm.MainAssembly, "#6");
 341                         Assert.AreEqual (Assembly.GetExecutingAssembly (), rm.MainAssembly, "#7");
 342                         Assert.IsNotNull (rm.ResourceSets, "#8");
 343                         Assert.AreEqual (0, rm.ResourceSets.Count, "#9");
 344                         Assert.IsNotNull (rm.ResourceSetType, "#10");
 345                         Assert.IsTrue (typeof (ResourceSet).IsAssignableFrom (rm.ResourceSetType), "#11");
 346                         Assert.IsFalse (typeof (ResourceSet) == rm.ResourceSetType, "#12");
 347                         Assert.AreEqual ("RuntimeResourceSet", rm.ResourceSetType.Name, "#13");
 348                 }
 349
 350                 [Test]
 351                 public void CreateFileBasedResourceManager_BaseName_Null ()
 352                 {
 353                         try {
 354                                 ResourceManager.CreateFileBasedResourceManager (
 355                                         (string) null, AppDomain.CurrentDomain.BaseDirectory,
 356                                         typeof (ResourceSet));
 357                                 Assert.Fail ("#1");
 358                         } catch (ArgumentNullException ex) {
 359                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 360                                 Assert.IsNull (ex.InnerException, "#3");
 361                                 Assert.IsNotNull (ex.Message, "#4");
 362                                 Assert.IsNotNull (ex.ParamName, "#5");
 363                                 Assert.AreEqual ("baseName", ex.ParamName, "#6");
 364                         }
 365                 }
 366
 367                 [Test]
 368                 [Category ("NotWorking")]
 369                 public void CreateFileBasedResourceManager_BaseName_Resources ()
 370                 {
 371                         ResourceManager rm = ResourceManager.CreateFileBasedResourceManager (
 372                                 "MyResources.resources", "Test/resources", null);
 373                         try {
 374                                 rm.GetResourceSet (CultureInfo.InvariantCulture, true, true);
 375                                 Assert.Fail ("#1");
 376                         } catch (MissingManifestResourceException ex) {
 377                                 // Could not find any resources appropriate for
 378                                 // the specified culture (or the neutral culture)
 379                                 //on disk
 380                                 Assert.AreEqual (typeof (MissingManifestResourceException), ex.GetType (), "#2");
 381                                 Assert.IsNull (ex.InnerException, "#3");
 382                                 Assert.IsNotNull (ex.Message, "#4");
 383                         }
 384                 }
 385
 386                 [Test]
 387                 public void CreateFileBasedResourceManager_ResourceDir_Null ()
 388                 {
 389                         try {
 390                                 ResourceManager.CreateFileBasedResourceManager (
 391                                         "whatever", (string) null,
 392                                         typeof (ResourceSet));
 393                                 Assert.Fail ("#1");
 394                         } catch (ArgumentNullException ex) {
 395                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 396                                 Assert.IsNull (ex.InnerException, "#3");
 397                                 Assert.IsNotNull (ex.Message, "#4");
 398                                 Assert.IsNotNull (ex.ParamName, "#5");
 399                                 Assert.AreEqual ("resourceDir", ex.ParamName, "#6");
 400                         }
 401                 }
 402
 403                 [Test]
 404                 public void CreateFileBasedResourceManager_UsingResourceSet_Invalid ()
 405                 {
 406                         ResourceManager rm = ResourceManager.CreateFileBasedResourceManager (
 407                                 "MyResources", "Test/resources", typeof (string));
 408                         Assert.IsNotNull (rm.BaseName, "#1");
 409                         Assert.AreEqual ("MyResources", rm.BaseName, "#2");
 410                         Assert.IsFalse (rm.IgnoreCase, "#3");
 411                         Assert.IsNotNull (rm.ResourceSetType, "#4");
 412                         Assert.AreEqual (typeof (string), rm.ResourceSetType, "#5");
 413                 }
 414
 415                 [Test]
 416                 public void CreateFileBasedResourceManager_UsingResourceSet_Null ()
 417                 {
 418                         ResourceManager rm = ResourceManager.CreateFileBasedResourceManager (
 419                                 "MyResources", "Test/resources", (Type) null);
 420                         Assert.IsNotNull (rm.BaseName, "#1");
 421                         Assert.AreEqual ("MyResources", rm.BaseName, "#2");
 422                         Assert.IsFalse (rm.IgnoreCase, "#3");
 423                         Assert.IsNotNull (rm.ResourceSetType, "#4");
 424                         Assert.IsTrue (typeof (ResourceSet).IsAssignableFrom (rm.ResourceSetType), "#5");
 425                         Assert.IsFalse (typeof (ResourceSet) == rm.ResourceSetType, "#6");
 426                         Assert.AreEqual ("RuntimeResourceSet", rm.ResourceSetType.Name, "#7");
 427                 }
 428
 429                 [Test]
 430                 public void GetObject ()
 431                 {
 432                         ResourceManager rm = ResourceManager.
 433                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 434
 435                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 436                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld"), "#A1");
 437                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", new CultureInfo ("de")), "#A2");
 438                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", (CultureInfo) null), "#A3");
 439                         Assert.IsNull (rm.GetObject ("deHelloWorld"), "#A4");
 440                         Assert.AreEqual ("Hallo Welt", rm.GetObject ("deHelloWorld", new CultureInfo ("de")), "#A5");
 441                         Assert.IsNull (rm.GetObject ("deHelloWorld", (CultureInfo) null), "#A6");
 442
 443                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("de");
 444                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld"), "#B1");
 445                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", (CultureInfo) null), "#B2");
 446                         Assert.AreEqual ("Hallo Welt", rm.GetObject ("deHelloWorld"), "#B3");
 447                         Assert.IsNull (rm.GetObject ("deHelloWorld", new CultureInfo ("nl-BE")), "#B4");
 448                         Assert.AreEqual ("Hallo Welt", rm.GetObject ("deHelloWorld", (CultureInfo) null), "#B5");
 449
 450                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("nl-BE");
 451                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld"), "#C1");
 452                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", new CultureInfo ("de")), "#C2");
 453                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", (CultureInfo) null), "#C3");
 454                         Assert.IsNull (rm.GetObject ("deHelloWorld"), "#C4");
 455                         Assert.AreEqual ("Hallo Welt", rm.GetObject ("deHelloWorld", new CultureInfo ("de")), "#C5");
 456                         Assert.IsNull (rm.GetObject ("deHelloWorld", (CultureInfo) null), "#C6");
 457
 458                         rm.ReleaseAllResources ();
 459                 }
 460
 461                 [Test]
 462                 public void GetObject_Name_Null ()
 463                 {
 464                         ResourceManager rm = new ResourceManager (typeof (string));
 465                         try {
 466                                 rm.GetObject ((string) null);
 467                                 Assert.Fail ("#A1");
 468                         } catch (ArgumentNullException ex) {
 469                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 470                                 Assert.IsNull (ex.InnerException, "#A3");
 471                                 Assert.IsNotNull (ex.Message, "#A4");
 472                                 Assert.IsNotNull (ex.ParamName, "#A5");
 473                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 474                         }
 475
 476                         try {
 477                                 rm.GetObject ((string) null, CultureInfo.InvariantCulture);
 478                                 Assert.Fail ("#B1");
 479                         } catch (ArgumentNullException ex) {
 480                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 481                                 Assert.IsNull (ex.InnerException, "#B3");
 482                                 Assert.IsNotNull (ex.Message, "#B4");
 483                                 Assert.IsNotNull (ex.ParamName, "#B5");
 484                                 Assert.AreEqual ("name", ex.ParamName, "#B6");
 485                         }
 486                         rm.ReleaseAllResources ();
 487                 }
 488
 489                 [Test]
 490                 public void GetObject_ResourceSet_Disposed ()
 491                 {
 492                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("de");
 493                         ResourceManager rm = ResourceManager.
 494                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 495                         ResourceSet rs = rm.GetResourceSet (new CultureInfo ("de"),
 496                                 true, true);
 497                         rs.Dispose ();
 498
 499                         try {
 500                                 rm.GetObject ("deHelloWorld");
 501                                 Assert.Fail ("#1");
 502                         } catch (ObjectDisposedException ex) {
 503                                 // Cannot access a closed resource set
 504                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 505                                 Assert.IsNull (ex.InnerException, "#3");
 506                                 Assert.IsNotNull (ex.Message, "#4");
 507                         } finally {
 508                                 rm.ReleaseAllResources ();
 509                         }
 510                 }
 511
 512                 [Test]
 513                 public void GetResourceFileName ()
 514                 {
 515                         MockResourceManager rm = new MockResourceManager ();
 516                         Assert.AreEqual (".nl-BE.resources",
 517                                 rm.GetResourceFileName (new CultureInfo ("nl-BE")), "#A1");
 518                         Assert.AreEqual (".fr.resources",
 519                                 rm.GetResourceFileName (new CultureInfo ("fr")), "#A2");
 520                         Assert.AreEqual (".resources",
 521                                 rm.GetResourceFileName (CultureInfo.InvariantCulture), "#A3");
 522
 523                         rm = new MockResourceManager (typeof (string));
 524                         Assert.AreEqual ("String.nl-BE.resources",
 525                                 rm.GetResourceFileName (new CultureInfo ("nl-BE")), "#B1");
 526                         Assert.AreEqual ("String.fr.resources",
 527                                 rm.GetResourceFileName (new CultureInfo ("fr")), "#B2");
 528                         Assert.AreEqual ("String.resources",
 529                                 rm.GetResourceFileName (CultureInfo.InvariantCulture), "#B3");
 530                 }
 531
 532                 [Test]
 533                 public void GetResourceFileName_Culture_Null ()
 534                 {
 535                         MockResourceManager rm = new MockResourceManager ();
 536                         try {
 537                                 rm.GetResourceFileName ((CultureInfo) null);
 538                                 Assert.Fail ("#1");
 539                         } catch (NullReferenceException) {
 540                         }
 541                 }
 542
 543                 [Test]
 544                 public void GetResourceSet_Culture_Null ()
 545                 {
 546                         ResourceManager rm = new ResourceManager (typeof (string));
 547                         try {
 548                                 rm.GetResourceSet ((CultureInfo) null, false, false);
 549                                 Assert.Fail ("#1");
 550                         } catch (ArgumentNullException ex) {
 551                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 552                                 Assert.IsNull (ex.InnerException, "#3");
 553                                 Assert.IsNotNull (ex.Message, "#4");
 554                                 Assert.IsNotNull (ex.ParamName, "#5");
 555                                 Assert.AreEqual ("culture", ex.ParamName, "#6");
 556                         }
 557                         rm.ReleaseAllResources ();
 558                 }
 559
 560                 [Test]
 561                 public void GetString ()
 562                 {
 563                         ResourceManager rm = ResourceManager.
 564                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 565
 566                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 567                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld"), "#A1");
 568                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", new CultureInfo ("de")), "#A2");
 569                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", (CultureInfo) null), "#A3");
 570                         Assert.IsNull (rm.GetString ("deHelloWorld"), "#A4");
 571                         Assert.AreEqual ("Hallo Welt", rm.GetString ("deHelloWorld", new CultureInfo ("de")), "#A5");
 572                         Assert.IsNull (rm.GetString ("deHelloWorld", (CultureInfo) null), "#A6");
 573
 574                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("de");
 575                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld"), "#B1");
 576                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", (CultureInfo) null), "#B2");
 577                         Assert.AreEqual ("Hallo Welt", rm.GetString ("deHelloWorld"), "#B3");
 578                         Assert.IsNull (rm.GetString ("deHelloWorld", new CultureInfo ("nl-BE")), "#B4");
 579                         Assert.AreEqual ("Hallo Welt", rm.GetString ("deHelloWorld", (CultureInfo) null), "#B5");
 580
 581                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("nl-BE");
 582                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld"), "#C1");
 583                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", new CultureInfo ("de")), "#C2");
 584                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", (CultureInfo) null), "#C3");
 585                         Assert.IsNull (rm.GetString ("deHelloWorld"), "#C4");
 586                         Assert.AreEqual ("Hallo Welt", rm.GetString ("deHelloWorld", new CultureInfo ("de")), "#C5");
 587                         Assert.IsNull (rm.GetString ("deHelloWorld", (CultureInfo) null), "#C6");
 588
 589                         rm.ReleaseAllResources ();
 590                 }
 591
 592                 [Test]
 593                 public void GetString_Name_Null ()
 594                 {
 595                         ResourceManager rm = new ResourceManager (typeof (string));
 596                         try {
 597                                 rm.GetString ((string) null);
 598                                 Assert.Fail ("#A1");
 599                         } catch (ArgumentNullException ex) {
 600                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 601                                 Assert.IsNull (ex.InnerException, "#A3");
 602                                 Assert.IsNotNull (ex.Message, "#A4");
 603                                 Assert.IsNotNull (ex.ParamName, "#A5");
 604                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 605                         }
 606
 607                         try {
 608                                 rm.GetString ((string) null, CultureInfo.InvariantCulture);
 609                                 Assert.Fail ("#B1");
 610                         } catch (ArgumentNullException ex) {
 611                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 612                                 Assert.IsNull (ex.InnerException, "#B3");
 613                                 Assert.IsNotNull (ex.Message, "#B4");
 614                                 Assert.IsNotNull (ex.ParamName, "#B5");
 615                                 Assert.AreEqual ("name", ex.ParamName, "#B6");
 616                         }
 617                         rm.ReleaseAllResources ();
 618                 }
 619
 620                 [Test]
 621                 public void GetString_ResourceSet_Disposed ()
 622                 {
 623                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("de");
 624                         ResourceManager rm = ResourceManager.
 625                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 626                         ResourceSet rs = rm.GetResourceSet (new CultureInfo ("de"),
 627                                 true, true);
 628                         rs.Dispose ();
 629
 630                         try {
 631                                 rm.GetString ("deHelloWorld");
 632                                 Assert.Fail ("#1");
 633                         } catch (ObjectDisposedException ex) {
 634                                 // Cannot access a closed resource set
 635                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 636                                 Assert.IsNull (ex.InnerException, "#3");
 637                                 Assert.IsNotNull (ex.Message, "#4");
 638                         } finally {
 639                                 rm.ReleaseAllResources ();
 640                         }
 641                 }
 642
 643                 [Test]
 644                 public void GetStream ()
 645                 {
 646                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 647                         ResourceManager rm = ResourceManager.
 648                                 CreateFileBasedResourceManager ("StreamTest", "Test/resources", null);
 649                         UnmanagedMemoryStream s = rm.GetStream ("test");
 650                         Assert.AreEqual (22, s.Length, "#A1");
 651                         Assert.AreEqual ("veritas vos liberabit\n", new StreamReader (s).ReadToEnd (), "#A2");
 652                         s.Close ();
 653
 654                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("ja-JP");
 655                         s = rm.GetStream ("test");
 656                         Assert.AreEqual (22, s.Length, "#B1");
 657                         Assert.AreEqual ("Veritas Vos Liberabit\n", new StreamReader (s).ReadToEnd (), "#B2");
 658                         s.Close ();
 659
 660                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("nl-BE");
 661                         s = rm.GetStream ("test");
 662                         Assert.AreEqual (22, s.Length, "#C1");
 663                         Assert.AreEqual ("veritas vos liberabit\n", new StreamReader (s).ReadToEnd (), "#C2");
 664                         rm.ReleaseAllResources ();
 665                 }
 666
 667                 [Test]
 668                 public void GetStream_Culture ()
 669                 {
 670                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 671                         ResourceManager rm = ResourceManager.
 672                                 CreateFileBasedResourceManager ("StreamTest", "Test/resources", null);
 673                         UnmanagedMemoryStream s = rm.GetStream ("test", new CultureInfo ("ja-JP"));
 674                         Assert.AreEqual (22, s.Length, "#1");
 675                         Assert.AreEqual ("Veritas Vos Liberabit\n", new StreamReader (s).ReadToEnd (), "#2");
 676                         s.Close ();
 677
 678                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 679                         s = rm.GetStream ("test", null);
 680                         Assert.AreEqual (22, s.Length, "#1");
 681                         Assert.AreEqual ("veritas vos liberabit\n", new StreamReader (s).ReadToEnd (), "#2");
 682                         s.Close ();
 683
 684                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("ja-JP");
 685                         s = rm.GetStream ("test", null);
 686                         Assert.AreEqual (22, s.Length, "#1");
 687                         Assert.AreEqual ("Veritas Vos Liberabit\n", new StreamReader (s).ReadToEnd (), "#2");
 688                         s.Close ();
 689                         rm.ReleaseAllResources ();
 690                 }
 691
 692                 [Test]
 693                 public void GetStream_Name_Null ()
 694                 {
 695                         ResourceManager rm = new ResourceManager (typeof (string));
 696                         try {
 697                                 rm.GetStream ((string) null);
 698                                 Assert.Fail ("#A1");
 699                         } catch (ArgumentNullException ex) {
 700                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 701                                 Assert.IsNull (ex.InnerException, "#A3");
 702                                 Assert.IsNotNull (ex.Message, "#A4");
 703                                 Assert.IsNotNull (ex.ParamName, "#A5");
 704                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 705                         }
 706
 707                         try {
 708                                 rm.GetStream ((string) null, CultureInfo.InvariantCulture);
 709                                 Assert.Fail ("#A1");
 710                         } catch (ArgumentNullException ex) {
 711                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 712                                 Assert.IsNull (ex.InnerException, "#A3");
 713                                 Assert.IsNotNull (ex.Message, "#A4");
 714                                 Assert.IsNotNull (ex.ParamName, "#A5");
 715                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 716                         }
 717                         rm.ReleaseAllResources ();
 718                 }
 719
 720                 [Test]
 721                 public void GetStream_Resource_DoesNotExist ()
 722                 {
 723                         ResourceManager rm = ResourceManager.
 724                                 CreateFileBasedResourceManager ("StreamTest", "Test/resources", null);
 725                         Assert.IsNull (rm.GetStream ("HelloWorld"));
 726                         rm.ReleaseAllResources ();
 727                 }
 728
 729                 [Test]
 730                 public void GetStream_Resource_NonStream ()
 731                 {
 732                         ResourceManager rm = ResourceManager.
 733                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 734
 735                         try {
 736                                 rm.GetStream ("HelloWorld", CultureInfo.InvariantCulture);
 737                                 Assert.Fail ("#1");
 738                         } catch (InvalidOperationException ex) {
 739                                 // Resource 'HelloWorld' was not a Stream - call
 740                                 // GetObject instead
 741                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 742                                 Assert.IsNull (ex.InnerException, "#3");
 743                                 Assert.IsNotNull (ex.Message, "#4");
 744                         } finally {
 745                                 rm.ReleaseAllResources ();
 746                         }
 747                 }
 748
 749                 [Test]
 750                 public void GetStream_ResourceFile_DoesNotExist ()
 751                 {
 752                         ResourceManager rm = ResourceManager.
 753                                 CreateFileBasedResourceManager ("DoesNotExist", "Test/resources", null);
 754                         try {
 755                                 rm.GetStream ("HelloWorld");
 756                                 Assert.Fail ("#1");
 757                         } catch (MissingManifestResourceException ex) {
 758                                 // Could not find any resources appropriate for
 759                                 // the specified culture (or the neutral culture)
 760                                 //on disk
 761                                 Assert.AreEqual (typeof (MissingManifestResourceException), ex.GetType (), "#2");
 762                                 Assert.IsNull (ex.InnerException, "#3");
 763                                 Assert.IsNotNull (ex.Message, "#4");
 764                         }
 765                 }
 766
 767                 [Test]
 768                 public void GetStream_ResourceSet_Disposed ()
 769                 {
 770                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 771                         ResourceManager rm = ResourceManager.
 772                                 CreateFileBasedResourceManager ("StreamTest", "Test/resources", null);
 773                         ResourceSet rs = rm.GetResourceSet (new CultureInfo ("ja-JP"),
 774                                 true, true);
 775                         rs.Dispose ();
 776
 777                         try {
 778                                 rm.GetStream ("test", new CultureInfo ("ja-JP"));
 779                                 Assert.Fail ("#1");
 780                         } catch (ObjectDisposedException ex) {
 781                                 // Cannot access a closed resource set
 782                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 783                                 Assert.IsNull (ex.InnerException, "#3");
 784                                 Assert.IsNotNull (ex.Message, "#4");
 785                         } finally {
 786                                 rm.ReleaseAllResources ();
 787                         }
 788                 }
 789
 790                 [Test]
 791                 public void IgnoreCase ()
 792                 {
 793                         ResourceManager rm = ResourceManager.
 794                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 795
 796                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 797                         Assert.IsFalse (rm.IgnoreCase, "#A1");
 798                         Assert.IsNull (rm.GetString ("helloWORLD"), "#A2");
 799                         rm.IgnoreCase = true;
 800                         Assert.IsTrue (rm.IgnoreCase, "#B1");
 801                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld"), "#B2");
 802                         rm.ReleaseAllResources ();
 803                 }
 804
 805                 [Test]
 806                 public void InternalGetResourceSet_Culture_Null ()
 807                 {
 808                         MockResourceManager rm = new MockResourceManager (typeof (string));
 809                         try {
 810                                 rm.InternalGetResourceSet ((CultureInfo) null, false, true);
 811                                 Assert.Fail ("#1");
 812                         } catch (ArgumentNullException ex) {
 813                                 // Key cannot be null
 814                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 815                                 Assert.IsNull (ex.InnerException, "#3");
 816                                 Assert.IsNotNull (ex.Message, "#4");
 817                                 Assert.IsNotNull (ex.ParamName, "#5");
 818                                 Assert.AreEqual ("key", ex.ParamName, "#6");
 819                         }
 820                 }
 821
 822                 [Test]
 823                 public void TestResourceManagerGetResourceSetEmpty ()
 824                 {
 825                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 826                         ResourceManagerPoker rm = new ResourceManagerPoker ();
 827                         try {
 828                                 rm.GetResourceSet (CultureInfo.InvariantCulture,
 829                                         true, true);
 830                                 Assert.Fail ("#1");
 831                         } catch (NullReferenceException) {
 832                         }
 833                 }
 834
 835                 [Test]
 836                 public void TestResourceManagerReleaseAllResourcesEmpty ()
 837                 {
 838                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 839                         ResourceManagerPoker rm = new ResourceManagerPoker ();
 840                         try {
 841                                 rm.ReleaseAllResources ();
 842                                 Assert.Fail ("#1");
 843                         } catch (NullReferenceException) {
 844                         }
 845                 }
 846
 847                 [Test]
 848                 public void TestResourceManagerReleaseAllResources ()
 849                 {
 850                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 851                         ResourceManagerPoker rm = new ResourceManagerPoker ();
 852                         rm.InitResourceSets ();
 853                         rm.ReleaseAllResources ();
 854                 }
 855
 856                 [Test]
 857                 public void TestResourceManagerResourceSets ()
 858                 {
 859                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 860                         ResourceManagerPoker rm = new ResourceManagerPoker ();
 861
 862                         rm.InitResourceSets ();
 863
 864                         ResourceSet rs = rm.GetResourceSet (CultureInfo.InvariantCulture,
 865                                                             true, true);
 866
 867                         Assert.AreEqual (1, rm.GetResourceSets().Keys.Count, "#01");
 868
 869                         rs.Close ();
 870
 871                         Assert.AreEqual (1, rm.GetResourceSets().Keys.Count, "#02");
 872
 873                         rs = rm.GetResourceSet (CultureInfo.InvariantCulture,
 874                                                 true, true);
 875
 876                         Assert.AreEqual (1, rm.GetResourceSets().Keys.Count, "#03");
 877
 878                         rm.ReleaseAllResources ();
 879                 }
 880
 881                 [Test]
 882                 public void TestResourceManagerResourceSetClosedException ()
 883                 {
 884                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 885                         ResourceManagerPoker rm = new ResourceManagerPoker ();
 886
 887                         rm.InitResourceSets ();
 888
 889                         ResourceSet rs = rm.GetResourceSet (CultureInfo.InvariantCulture,
 890                                                             true, true);
 891                         rs.Close ();
 892                         ResourceSet rs2 = rs;
 893                         rs = rm.GetResourceSet (CultureInfo.InvariantCulture, true, true);
 894                         Assert.IsTrue (Object.ReferenceEquals (rs2, rs), "#0");
 895
 896                         try {
 897                                 rm.GetString ("HelloWorld");
 898                                 Assert.Fail ("#1");
 899                         } catch (ObjectDisposedException ex) {
 900                                 // ResourceSet is closed
 901                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 902                                 Assert.IsNull (ex.InnerException, "#3");
 903                                 Assert.IsNotNull (ex.Message, "#4");
 904                         } finally {
 905                                 rm.ReleaseAllResources ();
 906                         }
 907                 }
 908
 909                 class MockResourceManager : ResourceManager
 910                 {
 911                         public MockResourceManager ()
 912                         {
 913                         }
 914
 915                         public MockResourceManager (Type resourceSource) : base (resourceSource)
 916                         {
 917                         }
 918
 919                         public MockResourceManager (string baseName, Assembly assembly)
 920                                 : base (baseName, assembly)
 921                         {
 922                         }
 923
 924                         public MockResourceManager (string baseName, Assembly assembly, Type usingResourceSet)
 925                                 : base (baseName, assembly, usingResourceSet)
 926                         {
 927                         }
 928
 929                         public new string BaseNameField {
 930                                 get { return base.BaseNameField; }
 931                         }
 932
 933                         public new Assembly MainAssembly {
 934                                 get { return base.MainAssembly; }
 935                         }
 936
 937                         public new Hashtable ResourceSets {
 938                                 get { return base.ResourceSets; }
 939                         }
 940
 941                         public new ResourceSet InternalGetResourceSet (CultureInfo culture, bool Createifnotexists, bool tryParents)
 942                         {
 943                                 return base.InternalGetResourceSet (culture,
 944                                         Createifnotexists, tryParents);
 945                         }
 946
 947                         public new string GetResourceFileName (CultureInfo culture)
 948                         {
 949                                 return base.GetResourceFileName (culture);
 950                         }
 951                 }
 952
 953                 class MockResourceSet : ResourceSet
 954                 {
 955                 }
 956         }
 957 }