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 #if NET_2_0
 188                         MockResourceManager rm = new MockResourceManager (
 189                                 "mono.resources",
 190                                 Assembly.GetExecutingAssembly ());
 191                         Assert.IsNotNull (rm.BaseName, "#1");
 192                         Assert.AreEqual ("mono.resources", rm.BaseName, "#2");
 193                         Assert.IsNotNull (rm.BaseNameField, "#3");
 194                         Assert.AreEqual ("mono.resources", rm.BaseNameField, "#4");
 195                         Assert.IsFalse (rm.IgnoreCase, "#5");
 196                         Assert.IsNotNull (rm.MainAssembly, "#6");
 197                         Assert.AreEqual (Assembly.GetExecutingAssembly (), rm.MainAssembly, "#7");
 198                         Assert.IsNotNull (rm.ResourceSets, "#8");
 199                         Assert.AreEqual (0, rm.ResourceSets.Count, "#9");
 200                         Assert.IsNotNull (rm.ResourceSetType, "#10");
 201                         Assert.IsTrue (typeof (ResourceSet).IsAssignableFrom (rm.ResourceSetType), "#11");
 202                         Assert.IsFalse (typeof (ResourceSet) == rm.ResourceSetType, "#12");
 203                         Assert.AreEqual ("RuntimeResourceSet", rm.ResourceSetType.Name, "#13");
 204 #else
 205                         try {
 206                                 new ResourceManager ("mono.resources",
 207                                         Assembly.GetExecutingAssembly ());
 208                                 Assert.Fail ("#1");
 209                         } catch (ArgumentException ex) {
 210                                 // ResourceManager base name should not end in
 211                                 // .resources. It should be similar to MyResources,
 212                                 // which the ResourceManager can convert into
 213                                 // MyResources.<culture>.resources; for example,
 214                                 // MyResources.en-US.resources
 215                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 216                                 Assert.IsNull (ex.InnerException, "#3");
 217                                 Assert.IsNotNull (ex.Message, "#4");
 218                                 Assert.IsTrue (ex.Message.IndexOf (" .resources") != -1, "#5");
 219                                 Assert.IsNull (ex.ParamName, "#6");
 220                         }
 221 #endif
 222                 }
 223
 224                 [Test] // ResourceManager (String, Assembly)
 225                 public void Constructor2_Assembly_Null ()
 226                 {
 227                         try {
 228                                 new ResourceManager (string.Empty, (Assembly) null);
 229                                 Assert.Fail ("#1");
 230                         } catch (ArgumentNullException ex) {
 231                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 232                                 Assert.IsNull (ex.InnerException, "#3");
 233                                 Assert.IsNotNull (ex.Message, "#4");
 234                                 Assert.IsNotNull (ex.ParamName, "#5");
 235                                 Assert.AreEqual ("assembly", ex.ParamName, "#6");
 236                         }
 237                 }
 238
 239                 [Test] // ResourceManager (String, Assembly, Type)
 240                 public void Constructor3 ()
 241                 {
 242                         MockResourceManager rm = null;
 243                         Assembly assembly = null;
 244
 245                         assembly = Assembly.GetExecutingAssembly ();
 246                         rm = new MockResourceManager ("mono", assembly,
 247                                 typeof (ResourceSet));
 248                         Assert.IsNotNull (rm.BaseName, "#A1");
 249                         Assert.AreEqual ("mono", rm.BaseName, "#A2");
 250                         Assert.IsNotNull (rm.BaseNameField, "#A3");
 251                         Assert.AreEqual ("mono", rm.BaseNameField, "#A4");
 252                         Assert.IsFalse (rm.IgnoreCase, "#A5");
 253                         Assert.IsNotNull (rm.MainAssembly, "#A6");
 254                         Assert.AreEqual (assembly, rm.MainAssembly, "#A7");
 255                         Assert.IsNotNull (rm.ResourceSets, "#A8");
 256                         Assert.AreEqual (0, rm.ResourceSets.Count, "#A9");
 257                         Assert.IsNotNull (rm.ResourceSetType, "#A10");
 258                         Assert.AreEqual (typeof (ResourceSet), rm.ResourceSetType, "#A11");
 259
 260                         assembly = typeof (int).Assembly;
 261                         rm = new MockResourceManager ("mono", assembly,
 262                                 typeof (MockResourceSet));
 263                         Assert.IsNotNull (rm.BaseName, "#B1");
 264                         Assert.AreEqual ("mono", rm.BaseName, "#B2");
 265                         Assert.IsNotNull (rm.BaseNameField, "#B3");
 266                         Assert.AreEqual ("mono", rm.BaseNameField, "#B4");
 267                         Assert.IsFalse (rm.IgnoreCase, "#B5");
 268                         Assert.IsNotNull (rm.MainAssembly, "#B6");
 269                         Assert.AreEqual (assembly, rm.MainAssembly, "#B7");
 270                         Assert.IsNotNull (rm.ResourceSets, "#B8");
 271                         Assert.AreEqual (0, rm.ResourceSets.Count, "#B9");
 272                         Assert.IsNotNull (rm.ResourceSetType, "#B10");
 273                         Assert.AreEqual (typeof (MockResourceSet), rm.ResourceSetType, "#B11");
 274                 }
 275
 276                 [Test] // ResourceManager (String, Assembly, Type)
 277                 public void Constructor3_BaseName_Null ()
 278                 {
 279                         try {
 280                                 new ResourceManager ((string) null, Assembly.
 281                                         GetExecutingAssembly (),
 282                                         typeof (ResourceSet));
 283                                 Assert.Fail ("#1");
 284                         } catch (ArgumentNullException ex) {
 285                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 286                                 Assert.IsNull (ex.InnerException, "#3");
 287                                 Assert.IsNotNull (ex.Message, "#4");
 288                                 Assert.IsNotNull (ex.ParamName, "#5");
 289                                 Assert.AreEqual ("baseName", ex.ParamName, "#6");
 290                         }
 291                 }
 292
 293                 [Test] // ResourceManager (String, Assembly, Type)
 294                 public void Constructor3_BaseName_Resources ()
 295                 {
 296 #if NET_2_0
 297                         MockResourceManager rm = new MockResourceManager (
 298                                 "mono.resources",
 299                                 Assembly.GetExecutingAssembly (),
 300                                 typeof (ResourceSet));
 301                         Assert.IsNotNull (rm.BaseName, "#1");
 302                         Assert.AreEqual ("mono.resources", rm.BaseName, "#2");
 303                         Assert.IsNotNull (rm.BaseNameField, "#3");
 304                         Assert.AreEqual ("mono.resources", rm.BaseNameField, "#4");
 305                         Assert.IsFalse (rm.IgnoreCase, "#5");
 306                         Assert.IsNotNull (rm.MainAssembly, "#6");
 307                         Assert.AreEqual (Assembly.GetExecutingAssembly (), rm.MainAssembly, "#7");
 308                         Assert.IsNotNull (rm.ResourceSets, "#8");
 309                         Assert.AreEqual (0, rm.ResourceSets.Count, "#9");
 310                         Assert.IsNotNull (rm.ResourceSetType, "#10");
 311                         Assert.AreEqual (typeof (ResourceSet), rm.ResourceSetType, "#11");
 312 #else
 313                         try {
 314                                 new ResourceManager ("mono.resources",
 315                                         Assembly.GetExecutingAssembly (),
 316                                         typeof (ResourceSet));
 317                                 Assert.Fail ("#1");
 318                         } catch (ArgumentException ex) {
 319                                 // ResourceManager base name should not end in
 320                                 // .resources. It should be similar to MyResources,
 321                                 // which the ResourceManager can convert into
 322                                 // MyResources.<culture>.resources; for example,
 323                                 // MyResources.en-US.resources
 324                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 325                                 Assert.IsNull (ex.InnerException, "#3");
 326                                 Assert.IsNotNull (ex.Message, "#4");
 327                                 Assert.IsTrue (ex.Message.IndexOf (" .resources") != -1, "#5");
 328                                 Assert.IsNull (ex.ParamName, "#6");
 329                         }
 330 #endif
 331                 }
 332
 333                 [Test] // ResourceManager (String, Assembly, Type)
 334                 public void Constructor3_Assembly_Null ()
 335                 {
 336                         try {
 337                                 new ResourceManager (string.Empty, (Assembly) null,
 338                                         typeof (ResourceSet));
 339                                 Assert.Fail ("#1");
 340                         } catch (ArgumentNullException ex) {
 341                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 342                                 Assert.IsNull (ex.InnerException, "#3");
 343                                 Assert.IsNotNull (ex.Message, "#4");
 344                                 Assert.IsNotNull (ex.ParamName, "#5");
 345                                 Assert.AreEqual ("assembly", ex.ParamName, "#6");
 346                         }
 347                 }
 348
 349                 [Test] // ResourceManager (String, Assembly, Type)
 350                 public void Constructor3_UsingResourceSet_Invalid ()
 351                 {
 352                         try {
 353                                 new ResourceManager ("mono", typeof (int).Assembly,
 354                                         typeof (string));
 355                                 Assert.Fail ("#1");
 356                         } catch (ArgumentException ex) {
 357                                 // Type parameter must refer to a subclass of
 358                                 // ResourceSet
 359                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 360                                 Assert.IsNull (ex.InnerException, "#3");
 361                                 Assert.IsNotNull (ex.Message, "#4");
 362                                 Assert.IsTrue (ex.Message.IndexOf ("ResourceSet") != -1, "#5");
 363                                 Assert.IsNotNull (ex.ParamName, "#6");
 364                                 Assert.AreEqual ("usingResourceSet", ex.ParamName, "#7");
 365                         }
 366                 }
 367
 368                 [Test] // ResourceManager (String, Assembly, Type)
 369                 public void Constructor3_UsingResourceSet_Null ()
 370                 {
 371                         MockResourceManager rm = new MockResourceManager (
 372                                 string.Empty, Assembly.GetExecutingAssembly (),
 373                                 (Type) null);
 374                         Assert.IsNotNull (rm.BaseName, "#1");
 375                         Assert.AreEqual (string.Empty, rm.BaseName, "#2");
 376                         Assert.IsNotNull (rm.BaseNameField, "#3");
 377                         Assert.AreEqual (string.Empty, rm.BaseNameField, "#4");
 378                         Assert.IsFalse (rm.IgnoreCase, "#5");
 379                         Assert.IsNotNull (rm.MainAssembly, "#6");
 380                         Assert.AreEqual (Assembly.GetExecutingAssembly (), rm.MainAssembly, "#7");
 381                         Assert.IsNotNull (rm.ResourceSets, "#8");
 382                         Assert.AreEqual (0, rm.ResourceSets.Count, "#9");
 383                         Assert.IsNotNull (rm.ResourceSetType, "#10");
 384                         Assert.IsTrue (typeof (ResourceSet).IsAssignableFrom (rm.ResourceSetType), "#11");
 385                         Assert.IsFalse (typeof (ResourceSet) == rm.ResourceSetType, "#12");
 386                         Assert.AreEqual ("RuntimeResourceSet", rm.ResourceSetType.Name, "#13");
 387                 }
 388
 389                 [Test]
 390                 public void CreateFileBasedResourceManager_BaseName_Null ()
 391                 {
 392                         try {
 393                                 ResourceManager.CreateFileBasedResourceManager (
 394                                         (string) null, AppDomain.CurrentDomain.BaseDirectory,
 395                                         typeof (ResourceSet));
 396                                 Assert.Fail ("#1");
 397                         } catch (ArgumentNullException ex) {
 398                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 399                                 Assert.IsNull (ex.InnerException, "#3");
 400                                 Assert.IsNotNull (ex.Message, "#4");
 401                                 Assert.IsNotNull (ex.ParamName, "#5");
 402                                 Assert.AreEqual ("baseName", ex.ParamName, "#6");
 403                         }
 404                 }
 405
 406                 [Test]
 407 #if NET_2_0
 408                 [Category ("NotWorking")]
 409 #endif
 410                 public void CreateFileBasedResourceManager_BaseName_Resources ()
 411                 {
 412 #if NET_2_0
 413                         ResourceManager rm = ResourceManager.CreateFileBasedResourceManager (
 414                                 "MyResources.resources", "Test/resources", null);
 415                         try {
 416                                 rm.GetResourceSet (CultureInfo.InvariantCulture, true, true);
 417                                 Assert.Fail ("#1");
 418                         } catch (MissingManifestResourceException ex) {
 419                                 // Could not find any resources appropriate for
 420                                 // the specified culture (or the neutral culture)
 421                                 //on disk
 422                                 Assert.AreEqual (typeof (MissingManifestResourceException), ex.GetType (), "#2");
 423                                 Assert.IsNull (ex.InnerException, "#3");
 424                                 Assert.IsNotNull (ex.Message, "#4");
 425                         }
 426 #else
 427                         try {
 428                                 ResourceManager.CreateFileBasedResourceManager (
 429                                         "MyResources.resources", "Test/resources",
 430                                         null);
 431                                 Assert.Fail ("#1");
 432                         } catch (ArgumentException ex) {
 433                                 // ResourceManager base name should not end in
 434                                 // .resources. It should be similar to MyResources,
 435                                 // which the ResourceManager can convert into
 436                                 // MyResources.<culture>.resources; for example,
 437                                 // MyResources.en-US.resources
 438                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 439                                 Assert.IsNull (ex.InnerException, "#3");
 440                                 Assert.IsNotNull (ex.Message, "#4");
 441                                 Assert.IsTrue (ex.Message.IndexOf (" .resources") != -1, "#5");
 442                                 Assert.IsNull (ex.ParamName, "#6");
 443                         }
 444 #endif
 445                 }
 446
 447                 [Test]
 448                 public void CreateFileBasedResourceManager_ResourceDir_Null ()
 449                 {
 450                         try {
 451                                 ResourceManager.CreateFileBasedResourceManager (
 452                                         "whatever", (string) null,
 453                                         typeof (ResourceSet));
 454                                 Assert.Fail ("#1");
 455                         } catch (ArgumentNullException ex) {
 456                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 457                                 Assert.IsNull (ex.InnerException, "#3");
 458                                 Assert.IsNotNull (ex.Message, "#4");
 459                                 Assert.IsNotNull (ex.ParamName, "#5");
 460                                 Assert.AreEqual ("resourceDir", ex.ParamName, "#6");
 461                         }
 462                 }
 463
 464                 [Test]
 465                 public void CreateFileBasedResourceManager_UsingResourceSet_Invalid ()
 466                 {
 467                         ResourceManager rm = ResourceManager.CreateFileBasedResourceManager (
 468                                 "MyResources", "Test/resources", typeof (string));
 469                         Assert.IsNotNull (rm.BaseName, "#1");
 470                         Assert.AreEqual ("MyResources", rm.BaseName, "#2");
 471                         Assert.IsFalse (rm.IgnoreCase, "#3");
 472                         Assert.IsNotNull (rm.ResourceSetType, "#4");
 473                         Assert.AreEqual (typeof (string), rm.ResourceSetType, "#5");
 474                 }
 475
 476                 [Test]
 477                 public void CreateFileBasedResourceManager_UsingResourceSet_Null ()
 478                 {
 479                         ResourceManager rm = ResourceManager.CreateFileBasedResourceManager (
 480                                 "MyResources", "Test/resources", (Type) null);
 481                         Assert.IsNotNull (rm.BaseName, "#1");
 482                         Assert.AreEqual ("MyResources", rm.BaseName, "#2");
 483                         Assert.IsFalse (rm.IgnoreCase, "#3");
 484                         Assert.IsNotNull (rm.ResourceSetType, "#4");
 485                         Assert.IsTrue (typeof (ResourceSet).IsAssignableFrom (rm.ResourceSetType), "#5");
 486                         Assert.IsFalse (typeof (ResourceSet) == rm.ResourceSetType, "#6");
 487                         Assert.AreEqual ("RuntimeResourceSet", rm.ResourceSetType.Name, "#7");
 488                 }
 489
 490                 [Test]
 491                 public void GetObject ()
 492                 {
 493                         ResourceManager rm = ResourceManager.
 494                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 495
 496                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 497                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld"), "#A1");
 498                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", new CultureInfo ("de")), "#A2");
 499                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", (CultureInfo) null), "#A3");
 500                         Assert.IsNull (rm.GetObject ("deHelloWorld"), "#A4");
 501                         Assert.AreEqual ("Hallo Welt", rm.GetObject ("deHelloWorld", new CultureInfo ("de")), "#A5");
 502                         Assert.IsNull (rm.GetObject ("deHelloWorld", (CultureInfo) null), "#A6");
 503
 504                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("de");
 505                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld"), "#B1");
 506                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", (CultureInfo) null), "#B2");
 507                         Assert.AreEqual ("Hallo Welt", rm.GetObject ("deHelloWorld"), "#B3");
 508                         Assert.IsNull (rm.GetObject ("deHelloWorld", new CultureInfo ("nl-BE")), "#B4");
 509                         Assert.AreEqual ("Hallo Welt", rm.GetObject ("deHelloWorld", (CultureInfo) null), "#B5");
 510
 511                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("nl-BE");
 512                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld"), "#C1");
 513                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", new CultureInfo ("de")), "#C2");
 514                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", (CultureInfo) null), "#C3");
 515                         Assert.IsNull (rm.GetObject ("deHelloWorld"), "#C4");
 516                         Assert.AreEqual ("Hallo Welt", rm.GetObject ("deHelloWorld", new CultureInfo ("de")), "#C5");
 517                         Assert.IsNull (rm.GetObject ("deHelloWorld", (CultureInfo) null), "#C6");
 518
 519                         rm.ReleaseAllResources ();
 520                 }
 521
 522                 [Test]
 523                 public void GetObject_Name_Null ()
 524                 {
 525                         ResourceManager rm = new ResourceManager (typeof (string));
 526                         try {
 527                                 rm.GetObject ((string) null);
 528                                 Assert.Fail ("#A1");
 529                         } catch (ArgumentNullException ex) {
 530                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 531                                 Assert.IsNull (ex.InnerException, "#A3");
 532                                 Assert.IsNotNull (ex.Message, "#A4");
 533                                 Assert.IsNotNull (ex.ParamName, "#A5");
 534                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 535                         }
 536
 537                         try {
 538                                 rm.GetObject ((string) null, CultureInfo.InvariantCulture);
 539                                 Assert.Fail ("#B1");
 540                         } catch (ArgumentNullException ex) {
 541                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 542                                 Assert.IsNull (ex.InnerException, "#B3");
 543                                 Assert.IsNotNull (ex.Message, "#B4");
 544                                 Assert.IsNotNull (ex.ParamName, "#B5");
 545                                 Assert.AreEqual ("name", ex.ParamName, "#B6");
 546                         }
 547                         rm.ReleaseAllResources ();
 548                 }
 549
 550                 [Test]
 551                 public void GetObject_ResourceSet_Disposed ()
 552                 {
 553                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("de");
 554                         ResourceManager rm = ResourceManager.
 555                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 556                         ResourceSet rs = rm.GetResourceSet (new CultureInfo ("de"),
 557                                 true, true);
 558                         rs.Dispose ();
 559
 560                         try {
 561                                 rm.GetObject ("deHelloWorld");
 562                                 Assert.Fail ("#1");
 563 #if NET_2_0
 564                         } catch (ObjectDisposedException ex) {
 565                                 // Cannot access a closed resource set
 566                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 567                                 Assert.IsNull (ex.InnerException, "#3");
 568                                 Assert.IsNotNull (ex.Message, "#4");
 569 #else
 570                         } catch (InvalidOperationException ex) {
 571                                 // Cannot access a closed resource set
 572                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 573                                 Assert.IsNull (ex.InnerException, "#3");
 574                                 Assert.IsNotNull (ex.Message, "#4");
 575 #endif
 576                         } finally {
 577                                 rm.ReleaseAllResources ();
 578                         }
 579                 }
 580
 581                 [Test]
 582                 public void GetResourceFileName ()
 583                 {
 584                         MockResourceManager rm = new MockResourceManager ();
 585                         Assert.AreEqual (".nl-BE.resources",
 586                                 rm.GetResourceFileName (new CultureInfo ("nl-BE")), "#A1");
 587                         Assert.AreEqual (".fr.resources",
 588                                 rm.GetResourceFileName (new CultureInfo ("fr")), "#A2");
 589                         Assert.AreEqual (".resources",
 590                                 rm.GetResourceFileName (CultureInfo.InvariantCulture), "#A3");
 591
 592                         rm = new MockResourceManager (typeof (string));
 593                         Assert.AreEqual ("String.nl-BE.resources",
 594                                 rm.GetResourceFileName (new CultureInfo ("nl-BE")), "#B1");
 595                         Assert.AreEqual ("String.fr.resources",
 596                                 rm.GetResourceFileName (new CultureInfo ("fr")), "#B2");
 597                         Assert.AreEqual ("String.resources",
 598                                 rm.GetResourceFileName (CultureInfo.InvariantCulture), "#B3");
 599                 }
 600
 601                 [Test]
 602                 public void GetResourceFileName_Culture_Null ()
 603                 {
 604                         MockResourceManager rm = new MockResourceManager ();
 605                         try {
 606                                 rm.GetResourceFileName ((CultureInfo) null);
 607                                 Assert.Fail ("#1");
 608                         } catch (NullReferenceException) {
 609                         }
 610                 }
 611
 612                 [Test]
 613                 public void GetResourceSet_Culture_Null ()
 614                 {
 615                         ResourceManager rm = new ResourceManager (typeof (string));
 616                         try {
 617                                 rm.GetResourceSet ((CultureInfo) null, false, false);
 618                                 Assert.Fail ("#1");
 619                         } catch (ArgumentNullException ex) {
 620                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 621                                 Assert.IsNull (ex.InnerException, "#3");
 622                                 Assert.IsNotNull (ex.Message, "#4");
 623                                 Assert.IsNotNull (ex.ParamName, "#5");
 624                                 Assert.AreEqual ("culture", ex.ParamName, "#6");
 625                         }
 626                         rm.ReleaseAllResources ();
 627                 }
 628
 629                 [Test]
 630                 public void GetString ()
 631                 {
 632                         ResourceManager rm = ResourceManager.
 633                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 634
 635                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 636                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld"), "#A1");
 637                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", new CultureInfo ("de")), "#A2");
 638                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", (CultureInfo) null), "#A3");
 639                         Assert.IsNull (rm.GetString ("deHelloWorld"), "#A4");
 640                         Assert.AreEqual ("Hallo Welt", rm.GetString ("deHelloWorld", new CultureInfo ("de")), "#A5");
 641                         Assert.IsNull (rm.GetString ("deHelloWorld", (CultureInfo) null), "#A6");
 642
 643                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("de");
 644                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld"), "#B1");
 645                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", (CultureInfo) null), "#B2");
 646                         Assert.AreEqual ("Hallo Welt", rm.GetString ("deHelloWorld"), "#B3");
 647                         Assert.IsNull (rm.GetString ("deHelloWorld", new CultureInfo ("nl-BE")), "#B4");
 648                         Assert.AreEqual ("Hallo Welt", rm.GetString ("deHelloWorld", (CultureInfo) null), "#B5");
 649
 650                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("nl-BE");
 651                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld"), "#C1");
 652                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", new CultureInfo ("de")), "#C2");
 653                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", (CultureInfo) null), "#C3");
 654                         Assert.IsNull (rm.GetString ("deHelloWorld"), "#C4");
 655                         Assert.AreEqual ("Hallo Welt", rm.GetString ("deHelloWorld", new CultureInfo ("de")), "#C5");
 656                         Assert.IsNull (rm.GetString ("deHelloWorld", (CultureInfo) null), "#C6");
 657
 658                         rm.ReleaseAllResources ();
 659                 }
 660
 661                 [Test]
 662                 public void GetString_Name_Null ()
 663                 {
 664                         ResourceManager rm = new ResourceManager (typeof (string));
 665                         try {
 666                                 rm.GetString ((string) null);
 667                                 Assert.Fail ("#A1");
 668                         } catch (ArgumentNullException ex) {
 669                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 670                                 Assert.IsNull (ex.InnerException, "#A3");
 671                                 Assert.IsNotNull (ex.Message, "#A4");
 672                                 Assert.IsNotNull (ex.ParamName, "#A5");
 673                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 674                         }
 675
 676                         try {
 677                                 rm.GetString ((string) null, CultureInfo.InvariantCulture);
 678                                 Assert.Fail ("#B1");
 679                         } catch (ArgumentNullException ex) {
 680                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 681                                 Assert.IsNull (ex.InnerException, "#B3");
 682                                 Assert.IsNotNull (ex.Message, "#B4");
 683                                 Assert.IsNotNull (ex.ParamName, "#B5");
 684                                 Assert.AreEqual ("name", ex.ParamName, "#B6");
 685                         }
 686                         rm.ReleaseAllResources ();
 687                 }
 688
 689                 [Test]
 690                 public void GetString_ResourceSet_Disposed ()
 691                 {
 692                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("de");
 693                         ResourceManager rm = ResourceManager.
 694                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 695                         ResourceSet rs = rm.GetResourceSet (new CultureInfo ("de"),
 696                                 true, true);
 697                         rs.Dispose ();
 698
 699                         try {
 700                                 rm.GetString ("deHelloWorld");
 701                                 Assert.Fail ("#1");
 702 #if NET_2_0
 703                         } catch (ObjectDisposedException ex) {
 704                                 // Cannot access a closed resource set
 705                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 706                                 Assert.IsNull (ex.InnerException, "#3");
 707                                 Assert.IsNotNull (ex.Message, "#4");
 708 #else
 709                         } catch (InvalidOperationException ex) {
 710                                 // ResourceSet is closed
 711                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 712                                 Assert.IsNull (ex.InnerException, "#3");
 713                                 Assert.IsNotNull (ex.Message, "#4");
 714 #endif
 715                         } finally {
 716                                 rm.ReleaseAllResources ();
 717                         }
 718                 }
 719
 720 #if NET_2_0
 721                 [Test]
 722                 public void GetStream ()
 723                 {
 724                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 725                         ResourceManager rm = ResourceManager.
 726                                 CreateFileBasedResourceManager ("StreamTest", "Test/resources", null);
 727                         UnmanagedMemoryStream s = rm.GetStream ("test");
 728                         Assert.AreEqual (22, s.Length, "#A1");
 729                         Assert.AreEqual ("veritas vos liberabit\n", new StreamReader (s).ReadToEnd (), "#A2");
 730                         s.Close ();
 731
 732                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("ja-JP");
 733                         s = rm.GetStream ("test");
 734                         Assert.AreEqual (22, s.Length, "#B1");
 735                         Assert.AreEqual ("Veritas Vos Liberabit\n", new StreamReader (s).ReadToEnd (), "#B2");
 736                         s.Close ();
 737
 738                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("nl-BE");
 739                         s = rm.GetStream ("test");
 740                         Assert.AreEqual (22, s.Length, "#C1");
 741                         Assert.AreEqual ("veritas vos liberabit\n", new StreamReader (s).ReadToEnd (), "#C2");
 742                         rm.ReleaseAllResources ();
 743                 }
 744
 745                 [Test]
 746                 public void GetStream_Culture ()
 747                 {
 748                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 749                         ResourceManager rm = ResourceManager.
 750                                 CreateFileBasedResourceManager ("StreamTest", "Test/resources", null);
 751                         UnmanagedMemoryStream s = rm.GetStream ("test", new CultureInfo ("ja-JP"));
 752                         Assert.AreEqual (22, s.Length, "#1");
 753                         Assert.AreEqual ("Veritas Vos Liberabit\n", new StreamReader (s).ReadToEnd (), "#2");
 754                         s.Close ();
 755
 756                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 757                         s = rm.GetStream ("test", null);
 758                         Assert.AreEqual (22, s.Length, "#1");
 759                         Assert.AreEqual ("veritas vos liberabit\n", new StreamReader (s).ReadToEnd (), "#2");
 760                         s.Close ();
 761
 762                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("ja-JP");
 763                         s = rm.GetStream ("test", null);
 764                         Assert.AreEqual (22, s.Length, "#1");
 765                         Assert.AreEqual ("Veritas Vos Liberabit\n", new StreamReader (s).ReadToEnd (), "#2");
 766                         s.Close ();
 767                         rm.ReleaseAllResources ();
 768                 }
 769
 770                 [Test]
 771                 public void GetStream_Name_Null ()
 772                 {
 773                         ResourceManager rm = new ResourceManager (typeof (string));
 774                         try {
 775                                 rm.GetStream ((string) null);
 776                                 Assert.Fail ("#A1");
 777                         } catch (ArgumentNullException ex) {
 778                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 779                                 Assert.IsNull (ex.InnerException, "#A3");
 780                                 Assert.IsNotNull (ex.Message, "#A4");
 781                                 Assert.IsNotNull (ex.ParamName, "#A5");
 782                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 783                         }
 784
 785                         try {
 786                                 rm.GetStream ((string) null, CultureInfo.InvariantCulture);
 787                                 Assert.Fail ("#A1");
 788                         } catch (ArgumentNullException ex) {
 789                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 790                                 Assert.IsNull (ex.InnerException, "#A3");
 791                                 Assert.IsNotNull (ex.Message, "#A4");
 792                                 Assert.IsNotNull (ex.ParamName, "#A5");
 793                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 794                         }
 795                         rm.ReleaseAllResources ();
 796                 }
 797
 798                 [Test]
 799                 public void GetStream_Resource_DoesNotExist ()
 800                 {
 801                         ResourceManager rm = ResourceManager.
 802                                 CreateFileBasedResourceManager ("StreamTest", "Test/resources", null);
 803                         Assert.IsNull (rm.GetStream ("HelloWorld"));
 804                         rm.ReleaseAllResources ();
 805                 }
 806
 807                 [Test]
 808                 public void GetStream_Resource_NonStream ()
 809                 {
 810                         ResourceManager rm = ResourceManager.
 811                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 812
 813                         try {
 814                                 rm.GetStream ("HelloWorld", CultureInfo.InvariantCulture);
 815                                 Assert.Fail ("#1");
 816                         } catch (InvalidOperationException ex) {
 817                                 // Resource 'HelloWorld' was not a Stream - call
 818                                 // GetObject instead
 819                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 820                                 Assert.IsNull (ex.InnerException, "#3");
 821                                 Assert.IsNotNull (ex.Message, "#4");
 822                         } finally {
 823                                 rm.ReleaseAllResources ();
 824                         }
 825                 }
 826
 827                 [Test]
 828                 public void GetStream_ResourceFile_DoesNotExist ()
 829                 {
 830                         ResourceManager rm = ResourceManager.
 831                                 CreateFileBasedResourceManager ("DoesNotExist", "Test/resources", null);
 832                         try {
 833                                 rm.GetStream ("HelloWorld");
 834                                 Assert.Fail ("#1");
 835                         } catch (MissingManifestResourceException ex) {
 836                                 // Could not find any resources appropriate for
 837                                 // the specified culture (or the neutral culture)
 838                                 //on disk
 839                                 Assert.AreEqual (typeof (MissingManifestResourceException), ex.GetType (), "#2");
 840                                 Assert.IsNull (ex.InnerException, "#3");
 841                                 Assert.IsNotNull (ex.Message, "#4");
 842                         }
 843                 }
 844
 845                 [Test]
 846                 public void GetStream_ResourceSet_Disposed ()
 847                 {
 848                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 849                         ResourceManager rm = ResourceManager.
 850                                 CreateFileBasedResourceManager ("StreamTest", "Test/resources", null);
 851                         ResourceSet rs = rm.GetResourceSet (new CultureInfo ("ja-JP"),
 852                                 true, true);
 853                         rs.Dispose ();
 854
 855                         try {
 856                                 rm.GetStream ("test", new CultureInfo ("ja-JP"));
 857                                 Assert.Fail ("#1");
 858                         } catch (ObjectDisposedException ex) {
 859                                 // Cannot access a closed resource set
 860                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 861                                 Assert.IsNull (ex.InnerException, "#3");
 862                                 Assert.IsNotNull (ex.Message, "#4");
 863                         } finally {
 864                                 rm.ReleaseAllResources ();
 865                         }
 866                 }
 867 #endif
 868
 869                 [Test]
 870                 public void IgnoreCase ()
 871                 {
 872                         ResourceManager rm = ResourceManager.
 873                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 874
 875                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 876                         Assert.IsFalse (rm.IgnoreCase, "#A1");
 877                         Assert.IsNull (rm.GetString ("helloWORLD"), "#A2");
 878                         rm.IgnoreCase = true;
 879                         Assert.IsTrue (rm.IgnoreCase, "#B1");
 880                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld"), "#B2");
 881                         rm.ReleaseAllResources ();
 882                 }
 883
 884                 [Test]
 885                 public void InternalGetResourceSet_Culture_Null ()
 886                 {
 887                         MockResourceManager rm = new MockResourceManager (typeof (string));
 888                         try {
 889                                 rm.InternalGetResourceSet ((CultureInfo) null, false, true);
 890                                 Assert.Fail ("#1");
 891                         } catch (ArgumentNullException ex) {
 892                                 // Key cannot be null
 893                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 894                                 Assert.IsNull (ex.InnerException, "#3");
 895                                 Assert.IsNotNull (ex.Message, "#4");
 896                                 Assert.IsNotNull (ex.ParamName, "#5");
 897                                 Assert.AreEqual ("key", ex.ParamName, "#6");
 898                         }
 899                 }
 900
 901                 [Test]
 902                 public void TestResourceManagerGetResourceSetEmpty ()
 903                 {
 904                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 905                         ResourceManagerPoker rm = new ResourceManagerPoker ();
 906                         try {
 907                                 rm.GetResourceSet (CultureInfo.InvariantCulture,
 908                                         true, true);
 909                                 Assert.Fail ("#1");
 910                         } catch (NullReferenceException) {
 911                         }
 912                 }
 913
 914                 [Test]
 915                 public void TestResourceManagerReleaseAllResourcesEmpty ()
 916                 {
 917                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 918                         ResourceManagerPoker rm = new ResourceManagerPoker ();
 919                         try {
 920                                 rm.ReleaseAllResources ();
 921                                 Assert.Fail ("#1");
 922                         } catch (NullReferenceException) {
 923                         }
 924                 }
 925
 926                 [Test]
 927                 public void TestResourceManagerReleaseAllResources ()
 928                 {
 929                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 930                         ResourceManagerPoker rm = new ResourceManagerPoker ();
 931                         rm.InitResourceSets ();
 932                         rm.ReleaseAllResources ();
 933                 }
 934
 935                 [Test]
 936                 public void TestResourceManagerResourceSets ()
 937                 {
 938                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 939                         ResourceManagerPoker rm = new ResourceManagerPoker ();
 940
 941                         rm.InitResourceSets ();
 942
 943                         ResourceSet rs = rm.GetResourceSet (CultureInfo.InvariantCulture,
 944                                                             true, true);
 945
 946                         Assert.AreEqual (1, rm.GetResourceSets().Keys.Count, "#01");
 947
 948                         rs.Close ();
 949
 950                         Assert.AreEqual (1, rm.GetResourceSets().Keys.Count, "#02");
 951
 952                         rs = rm.GetResourceSet (CultureInfo.InvariantCulture,
 953                                                 true, true);
 954
 955                         Assert.AreEqual (1, rm.GetResourceSets().Keys.Count, "#03");
 956
 957                         rm.ReleaseAllResources ();
 958                 }
 959
 960                 [Test]
 961                 public void TestResourceManagerResourceSetClosedException ()
 962                 {
 963                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 964                         ResourceManagerPoker rm = new ResourceManagerPoker ();
 965
 966                         rm.InitResourceSets ();
 967
 968                         ResourceSet rs = rm.GetResourceSet (CultureInfo.InvariantCulture,
 969                                                             true, true);
 970                         rs.Close ();
 971                         ResourceSet rs2 = rs;
 972                         rs = rm.GetResourceSet (CultureInfo.InvariantCulture, true, true);
 973                         Assert.IsTrue (Object.ReferenceEquals (rs2, rs), "#0");
 974
 975                         try {
 976                                 rm.GetString ("HelloWorld");
 977                                 Assert.Fail ("#1");
 978 #if NET_2_0
 979                         } catch (ObjectDisposedException ex) {
 980                                 // ResourceSet is closed
 981                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 982                                 Assert.IsNull (ex.InnerException, "#3");
 983                                 Assert.IsNotNull (ex.Message, "#4");
 984 #else
 985                         } catch (InvalidOperationException ex) {
 986                                 // ResourceSet is closed
 987                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 988                                 Assert.IsNull (ex.InnerException, "#3");
 989                                 Assert.IsNotNull (ex.Message, "#4");
 990 #endif
 991                         } finally {
 992                                 rm.ReleaseAllResources ();
 993                         }
 994                 }
 995
 996                 class MockResourceManager : ResourceManager
 997                 {
 998                         public MockResourceManager ()
 999                         {
1000                         }
1001
1002                         public MockResourceManager (Type resourceSource) : base (resourceSource)
1003                         {
1004                         }
1005
1006                         public MockResourceManager (string baseName, Assembly assembly)
1007                                 : base (baseName, assembly)
1008                         {
1009                         }
1010
1011                         public MockResourceManager (string baseName, Assembly assembly, Type usingResourceSet)
1012                                 : base (baseName, assembly, usingResourceSet)
1013                         {
1014                         }
1015
1016                         public new string BaseNameField {
1017                                 get { return base.BaseNameField; }
1018                         }
1019
1020                         public new Assembly MainAssembly {
1021                                 get { return base.MainAssembly; }
1022                         }
1023
1024                         public new Hashtable ResourceSets {
1025                                 get { return base.ResourceSets; }
1026                         }
1027
1028                         public new ResourceSet InternalGetResourceSet (CultureInfo culture, bool Createifnotexists, bool tryParents)
1029                         {
1030                                 return base.InternalGetResourceSet (culture,
1031                                         Createifnotexists, tryParents);
1032                         }
1033
1034                         public new string GetResourceFileName (CultureInfo culture)
1035                         {
1036                                 return base.GetResourceFileName (culture);
1037                         }
1038                 }
1039
1040                 class MockResourceSet : ResourceSet
1041                 {
1042                 }
1043         }
1044 }