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                 [Category ("MobileNotWorking")]
 431                 public void GetObject ()
 432                 {
 433                         ResourceManager rm = ResourceManager.
 434                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 435
 436                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 437                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld"), "#A1");
 438                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", new CultureInfo ("de")), "#A2");
 439                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", (CultureInfo) null), "#A3");
 440                         Assert.IsNull (rm.GetObject ("deHelloWorld"), "#A4");
 441                         Assert.AreEqual ("Hallo Welt", rm.GetObject ("deHelloWorld", new CultureInfo ("de")), "#A5");
 442                         Assert.IsNull (rm.GetObject ("deHelloWorld", (CultureInfo) null), "#A6");
 443
 444                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("de");
 445                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld"), "#B1");
 446                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", (CultureInfo) null), "#B2");
 447                         Assert.AreEqual ("Hallo Welt", rm.GetObject ("deHelloWorld"), "#B3");
 448                         Assert.IsNull (rm.GetObject ("deHelloWorld", new CultureInfo ("nl-BE")), "#B4");
 449                         Assert.AreEqual ("Hallo Welt", rm.GetObject ("deHelloWorld", (CultureInfo) null), "#B5");
 450
 451                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("nl-BE");
 452                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld"), "#C1");
 453                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", new CultureInfo ("de")), "#C2");
 454                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", (CultureInfo) null), "#C3");
 455                         Assert.IsNull (rm.GetObject ("deHelloWorld"), "#C4");
 456                         Assert.AreEqual ("Hallo Welt", rm.GetObject ("deHelloWorld", new CultureInfo ("de")), "#C5");
 457                         Assert.IsNull (rm.GetObject ("deHelloWorld", (CultureInfo) null), "#C6");
 458
 459                         rm.ReleaseAllResources ();
 460                 }
 461
 462                 [Test]
 463                 public void GetObject_Name_Null ()
 464                 {
 465                         ResourceManager rm = new ResourceManager (typeof (string));
 466                         try {
 467                                 rm.GetObject ((string) null);
 468                                 Assert.Fail ("#A1");
 469                         } catch (ArgumentNullException ex) {
 470                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 471                                 Assert.IsNull (ex.InnerException, "#A3");
 472                                 Assert.IsNotNull (ex.Message, "#A4");
 473                                 Assert.IsNotNull (ex.ParamName, "#A5");
 474                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 475                         }
 476
 477                         try {
 478                                 rm.GetObject ((string) null, CultureInfo.InvariantCulture);
 479                                 Assert.Fail ("#B1");
 480                         } catch (ArgumentNullException ex) {
 481                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 482                                 Assert.IsNull (ex.InnerException, "#B3");
 483                                 Assert.IsNotNull (ex.Message, "#B4");
 484                                 Assert.IsNotNull (ex.ParamName, "#B5");
 485                                 Assert.AreEqual ("name", ex.ParamName, "#B6");
 486                         }
 487                         rm.ReleaseAllResources ();
 488                 }
 489
 490                 [Test]
 491                 [Category ("MobileNotWorking")]
 492                 public void GetObject_ResourceSet_Disposed ()
 493                 {
 494                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("de");
 495                         ResourceManager rm = ResourceManager.
 496                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 497                         ResourceSet rs = rm.GetResourceSet (new CultureInfo ("de"),
 498                                 true, true);
 499                         rs.Dispose ();
 500
 501                         try {
 502                                 rm.GetObject ("deHelloWorld");
 503                                 Assert.Fail ("#1");
 504                         } catch (ObjectDisposedException ex) {
 505                                 // Cannot access a closed resource set
 506                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 507                                 Assert.IsNull (ex.InnerException, "#3");
 508                                 Assert.IsNotNull (ex.Message, "#4");
 509                         } finally {
 510                                 rm.ReleaseAllResources ();
 511                         }
 512                 }
 513
 514                 [Test]
 515                 public void GetResourceFileName ()
 516                 {
 517                         MockResourceManager rm = new MockResourceManager ();
 518                         Assert.AreEqual (".nl-BE.resources",
 519                                 rm.GetResourceFileName (new CultureInfo ("nl-BE")), "#A1");
 520                         Assert.AreEqual (".fr.resources",
 521                                 rm.GetResourceFileName (new CultureInfo ("fr")), "#A2");
 522                         Assert.AreEqual (".resources",
 523                                 rm.GetResourceFileName (CultureInfo.InvariantCulture), "#A3");
 524
 525                         rm = new MockResourceManager (typeof (string));
 526                         Assert.AreEqual ("String.nl-BE.resources",
 527                                 rm.GetResourceFileName (new CultureInfo ("nl-BE")), "#B1");
 528                         Assert.AreEqual ("String.fr.resources",
 529                                 rm.GetResourceFileName (new CultureInfo ("fr")), "#B2");
 530                         Assert.AreEqual ("String.resources",
 531                                 rm.GetResourceFileName (CultureInfo.InvariantCulture), "#B3");
 532                 }
 533
 534                 [Test]
 535                 public void GetResourceFileName_Culture_Null ()
 536                 {
 537                         MockResourceManager rm = new MockResourceManager ();
 538                         try {
 539                                 rm.GetResourceFileName ((CultureInfo) null);
 540                                 Assert.Fail ("#1");
 541                         } catch (NullReferenceException) {
 542                         }
 543                 }
 544
 545                 [Test]
 546                 public void GetResourceSet_Culture_Null ()
 547                 {
 548                         ResourceManager rm = new ResourceManager (typeof (string));
 549                         try {
 550                                 rm.GetResourceSet ((CultureInfo) null, false, false);
 551                                 Assert.Fail ("#1");
 552                         } catch (ArgumentNullException ex) {
 553                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 554                                 Assert.IsNull (ex.InnerException, "#3");
 555                                 Assert.IsNotNull (ex.Message, "#4");
 556                                 Assert.IsNotNull (ex.ParamName, "#5");
 557                                 Assert.AreEqual ("culture", ex.ParamName, "#6");
 558                         }
 559                         rm.ReleaseAllResources ();
 560                 }
 561
 562                 [Test]
 563                 [Category ("MobileNotWorking")]
 564                 public void GetString ()
 565                 {
 566                         ResourceManager rm = ResourceManager.
 567                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 568
 569                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 570                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld"), "#A1");
 571                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", new CultureInfo ("de")), "#A2");
 572                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", (CultureInfo) null), "#A3");
 573                         Assert.IsNull (rm.GetString ("deHelloWorld"), "#A4");
 574                         Assert.AreEqual ("Hallo Welt", rm.GetString ("deHelloWorld", new CultureInfo ("de")), "#A5");
 575                         Assert.IsNull (rm.GetString ("deHelloWorld", (CultureInfo) null), "#A6");
 576
 577                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("de");
 578                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld"), "#B1");
 579                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", (CultureInfo) null), "#B2");
 580                         Assert.AreEqual ("Hallo Welt", rm.GetString ("deHelloWorld"), "#B3");
 581                         Assert.IsNull (rm.GetString ("deHelloWorld", new CultureInfo ("nl-BE")), "#B4");
 582                         Assert.AreEqual ("Hallo Welt", rm.GetString ("deHelloWorld", (CultureInfo) null), "#B5");
 583
 584                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("nl-BE");
 585                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld"), "#C1");
 586                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", new CultureInfo ("de")), "#C2");
 587                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", (CultureInfo) null), "#C3");
 588                         Assert.IsNull (rm.GetString ("deHelloWorld"), "#C4");
 589                         Assert.AreEqual ("Hallo Welt", rm.GetString ("deHelloWorld", new CultureInfo ("de")), "#C5");
 590                         Assert.IsNull (rm.GetString ("deHelloWorld", (CultureInfo) null), "#C6");
 591
 592                         rm.ReleaseAllResources ();
 593                 }
 594
 595                 [Test]
 596                 public void GetString_Name_Null ()
 597                 {
 598                         ResourceManager rm = new ResourceManager (typeof (string));
 599                         try {
 600                                 rm.GetString ((string) null);
 601                                 Assert.Fail ("#A1");
 602                         } catch (ArgumentNullException ex) {
 603                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 604                                 Assert.IsNull (ex.InnerException, "#A3");
 605                                 Assert.IsNotNull (ex.Message, "#A4");
 606                                 Assert.IsNotNull (ex.ParamName, "#A5");
 607                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 608                         }
 609
 610                         try {
 611                                 rm.GetString ((string) null, CultureInfo.InvariantCulture);
 612                                 Assert.Fail ("#B1");
 613                         } catch (ArgumentNullException ex) {
 614                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 615                                 Assert.IsNull (ex.InnerException, "#B3");
 616                                 Assert.IsNotNull (ex.Message, "#B4");
 617                                 Assert.IsNotNull (ex.ParamName, "#B5");
 618                                 Assert.AreEqual ("name", ex.ParamName, "#B6");
 619                         }
 620                         rm.ReleaseAllResources ();
 621                 }
 622
 623                 [Test]
 624                 [Category ("MobileNotWorking")]
 625                 public void GetString_ResourceSet_Disposed ()
 626                 {
 627                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("de");
 628                         ResourceManager rm = ResourceManager.
 629                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 630                         ResourceSet rs = rm.GetResourceSet (new CultureInfo ("de"),
 631                                 true, true);
 632                         rs.Dispose ();
 633
 634                         try {
 635                                 rm.GetString ("deHelloWorld");
 636                                 Assert.Fail ("#1");
 637                         } catch (ObjectDisposedException ex) {
 638                                 // Cannot access a closed resource set
 639                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 640                                 Assert.IsNull (ex.InnerException, "#3");
 641                                 Assert.IsNotNull (ex.Message, "#4");
 642                         } finally {
 643                                 rm.ReleaseAllResources ();
 644                         }
 645                 }
 646
 647                 [Test]
 648                 [Category ("MobileNotWorking")]
 649                 public void GetStream ()
 650                 {
 651                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 652                         ResourceManager rm = ResourceManager.
 653                                 CreateFileBasedResourceManager ("StreamTest", "Test/resources", null);
 654                         UnmanagedMemoryStream s = rm.GetStream ("test");
 655                         Assert.AreEqual (22, s.Length, "#A1");
 656                         Assert.AreEqual ("veritas vos liberabit\n", new StreamReader (s).ReadToEnd (), "#A2");
 657                         s.Close ();
 658
 659                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("ja-JP");
 660                         s = rm.GetStream ("test");
 661                         Assert.AreEqual (22, s.Length, "#B1");
 662                         Assert.AreEqual ("Veritas Vos Liberabit\n", new StreamReader (s).ReadToEnd (), "#B2");
 663                         s.Close ();
 664
 665                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("nl-BE");
 666                         s = rm.GetStream ("test");
 667                         Assert.AreEqual (22, s.Length, "#C1");
 668                         Assert.AreEqual ("veritas vos liberabit\n", new StreamReader (s).ReadToEnd (), "#C2");
 669                         rm.ReleaseAllResources ();
 670                 }
 671
 672                 [Test]
 673                 [Category ("MobileNotWorking")]
 674                 public void GetStream_Culture ()
 675                 {
 676                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 677                         ResourceManager rm = ResourceManager.
 678                                 CreateFileBasedResourceManager ("StreamTest", "Test/resources", null);
 679                         UnmanagedMemoryStream s = rm.GetStream ("test", new CultureInfo ("ja-JP"));
 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 = CultureInfo.InvariantCulture;
 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
 690                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("ja-JP");
 691                         s = rm.GetStream ("test", null);
 692                         Assert.AreEqual (22, s.Length, "#1");
 693                         Assert.AreEqual ("Veritas Vos Liberabit\n", new StreamReader (s).ReadToEnd (), "#2");
 694                         s.Close ();
 695                         rm.ReleaseAllResources ();
 696                 }
 697
 698                 [Test]
 699                 public void GetStream_Name_Null ()
 700                 {
 701                         ResourceManager rm = new ResourceManager (typeof (string));
 702                         try {
 703                                 rm.GetStream ((string) null);
 704                                 Assert.Fail ("#A1");
 705                         } catch (ArgumentNullException ex) {
 706                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 707                                 Assert.IsNull (ex.InnerException, "#A3");
 708                                 Assert.IsNotNull (ex.Message, "#A4");
 709                                 Assert.IsNotNull (ex.ParamName, "#A5");
 710                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 711                         }
 712
 713                         try {
 714                                 rm.GetStream ((string) null, CultureInfo.InvariantCulture);
 715                                 Assert.Fail ("#A1");
 716                         } catch (ArgumentNullException ex) {
 717                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 718                                 Assert.IsNull (ex.InnerException, "#A3");
 719                                 Assert.IsNotNull (ex.Message, "#A4");
 720                                 Assert.IsNotNull (ex.ParamName, "#A5");
 721                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 722                         }
 723                         rm.ReleaseAllResources ();
 724                 }
 725
 726                 [Test]
 727                 [Category ("MobileNotWorking")]
 728                 public void GetStream_Resource_DoesNotExist ()
 729                 {
 730                         ResourceManager rm = ResourceManager.
 731                                 CreateFileBasedResourceManager ("StreamTest", "Test/resources", null);
 732                         Assert.IsNull (rm.GetStream ("HelloWorld"));
 733                         rm.ReleaseAllResources ();
 734                 }
 735
 736                 [Test]
 737                 [Category ("MobileNotWorking")]
 738                 public void GetStream_Resource_NonStream ()
 739                 {
 740                         ResourceManager rm = ResourceManager.
 741                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 742
 743                         try {
 744                                 rm.GetStream ("HelloWorld", CultureInfo.InvariantCulture);
 745                                 Assert.Fail ("#1");
 746                         } catch (InvalidOperationException ex) {
 747                                 // Resource 'HelloWorld' was not a Stream - call
 748                                 // GetObject instead
 749                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 750                                 Assert.IsNull (ex.InnerException, "#3");
 751                                 Assert.IsNotNull (ex.Message, "#4");
 752                         } finally {
 753                                 rm.ReleaseAllResources ();
 754                         }
 755                 }
 756
 757                 [Test]
 758                 public void GetStream_ResourceFile_DoesNotExist ()
 759                 {
 760                         ResourceManager rm = ResourceManager.
 761                                 CreateFileBasedResourceManager ("DoesNotExist", "Test/resources", null);
 762                         try {
 763                                 rm.GetStream ("HelloWorld");
 764                                 Assert.Fail ("#1");
 765                         } catch (MissingManifestResourceException ex) {
 766                                 // Could not find any resources appropriate for
 767                                 // the specified culture (or the neutral culture)
 768                                 //on disk
 769                                 Assert.AreEqual (typeof (MissingManifestResourceException), ex.GetType (), "#2");
 770                                 Assert.IsNull (ex.InnerException, "#3");
 771                                 Assert.IsNotNull (ex.Message, "#4");
 772                         }
 773                 }
 774
 775                 [Test]
 776                 [Category ("MobileNotWorking")]
 777                 public void GetStream_ResourceSet_Disposed ()
 778                 {
 779                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 780                         ResourceManager rm = ResourceManager.
 781                                 CreateFileBasedResourceManager ("StreamTest", "Test/resources", null);
 782                         ResourceSet rs = rm.GetResourceSet (new CultureInfo ("ja-JP"),
 783                                 true, true);
 784                         rs.Dispose ();
 785
 786                         try {
 787                                 rm.GetStream ("test", new CultureInfo ("ja-JP"));
 788                                 Assert.Fail ("#1");
 789                         } catch (ObjectDisposedException ex) {
 790                                 // Cannot access a closed resource set
 791                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 792                                 Assert.IsNull (ex.InnerException, "#3");
 793                                 Assert.IsNotNull (ex.Message, "#4");
 794                         } finally {
 795                                 rm.ReleaseAllResources ();
 796                         }
 797                 }
 798
 799                 [Test]
 800                 [Category ("MobileNotWorking")]
 801                 public void IgnoreCase ()
 802                 {
 803                         ResourceManager rm = ResourceManager.
 804                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 805
 806                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 807                         Assert.IsFalse (rm.IgnoreCase, "#A1");
 808                         Assert.IsNull (rm.GetString ("helloWORLD"), "#A2");
 809                         rm.IgnoreCase = true;
 810                         Assert.IsTrue (rm.IgnoreCase, "#B1");
 811                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld"), "#B2");
 812                         rm.ReleaseAllResources ();
 813                 }
 814
 815                 [Test]
 816                 public void InternalGetResourceSet_Culture_Null ()
 817                 {
 818                         MockResourceManager rm = new MockResourceManager (typeof (string));
 819                         try {
 820                                 rm.InternalGetResourceSet ((CultureInfo) null, false, true);
 821                                 Assert.Fail ("#1");
 822                         } catch (ArgumentNullException ex) {
 823                                 // Key cannot be null
 824                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 825                                 Assert.IsNull (ex.InnerException, "#3");
 826                                 Assert.IsNotNull (ex.Message, "#4");
 827                                 Assert.IsNotNull (ex.ParamName, "#5");
 828                                 Assert.AreEqual ("key", ex.ParamName, "#6");
 829                         }
 830                 }
 831
 832                 [Test]
 833                 public void TestResourceManagerGetResourceSetEmpty ()
 834                 {
 835                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 836                         ResourceManagerPoker rm = new ResourceManagerPoker ();
 837                         try {
 838                                 rm.GetResourceSet (CultureInfo.InvariantCulture,
 839                                         true, true);
 840                                 Assert.Fail ("#1");
 841                         } catch (NullReferenceException) {
 842                         }
 843                 }
 844
 845                 [Test]
 846                 public void TestResourceManagerReleaseAllResourcesEmpty ()
 847                 {
 848                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 849                         ResourceManagerPoker rm = new ResourceManagerPoker ();
 850                         try {
 851                                 rm.ReleaseAllResources ();
 852                                 Assert.Fail ("#1");
 853                         } catch (NullReferenceException) {
 854                         }
 855                 }
 856
 857                 [Test]
 858                 public void TestResourceManagerReleaseAllResources ()
 859                 {
 860                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 861                         ResourceManagerPoker rm = new ResourceManagerPoker ();
 862                         rm.InitResourceSets ();
 863                         rm.ReleaseAllResources ();
 864                 }
 865
 866                 [Test]
 867                 [Category ("MobileNotWorking")]
 868                 public void TestResourceManagerResourceSets ()
 869                 {
 870                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 871                         ResourceManagerPoker rm = new ResourceManagerPoker ();
 872
 873                         rm.InitResourceSets ();
 874
 875                         ResourceSet rs = rm.GetResourceSet (CultureInfo.InvariantCulture,
 876                                                             true, true);
 877
 878                         Assert.AreEqual (1, rm.GetResourceSets().Keys.Count, "#01");
 879
 880                         rs.Close ();
 881
 882                         Assert.AreEqual (1, rm.GetResourceSets().Keys.Count, "#02");
 883
 884                         rs = rm.GetResourceSet (CultureInfo.InvariantCulture,
 885                                                 true, true);
 886
 887                         Assert.AreEqual (1, rm.GetResourceSets().Keys.Count, "#03");
 888
 889                         rm.ReleaseAllResources ();
 890                 }
 891
 892                 [Test]
 893                 [Category ("MobileNotWorking")]
 894                 public void TestResourceManagerResourceSetClosedException ()
 895                 {
 896                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 897                         ResourceManagerPoker rm = new ResourceManagerPoker ();
 898
 899                         rm.InitResourceSets ();
 900
 901                         ResourceSet rs = rm.GetResourceSet (CultureInfo.InvariantCulture,
 902                                                             true, true);
 903                         rs.Close ();
 904                         ResourceSet rs2 = rs;
 905                         rs = rm.GetResourceSet (CultureInfo.InvariantCulture, true, true);
 906                         Assert.IsTrue (Object.ReferenceEquals (rs2, rs), "#0");
 907
 908                         try {
 909                                 rm.GetString ("HelloWorld");
 910                                 Assert.Fail ("#1");
 911                         } catch (ObjectDisposedException ex) {
 912                                 // ResourceSet is closed
 913                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 914                                 Assert.IsNull (ex.InnerException, "#3");
 915                                 Assert.IsNotNull (ex.Message, "#4");
 916                         } finally {
 917                                 rm.ReleaseAllResources ();
 918                         }
 919                 }
 920
 921                 [Test]
 922                 public void TestSatellites ()
 923                 {
 924                         ResourceManager manager = new ResourceManager("Resources", GetType ().Assembly);
 925
 926                         Assert.AreEqual ("Hei", manager.GetString ("Hello", new CultureInfo ("nn-NO")), "nn-NO");
 927                         Assert.AreEqual ("Hola", manager.GetString ("Hello", new CultureInfo ("es-ES")), "es-ES");
 928                         Assert.AreEqual ("Hello", manager.GetString ("Hello", new CultureInfo ("en-US")), "en-US");
 929                 }
 930
 931                 class MockResourceManager : ResourceManager
 932                 {
 933                         public MockResourceManager ()
 934                         {
 935                         }
 936
 937                         public MockResourceManager (Type resourceSource) : base (resourceSource)
 938                         {
 939                         }
 940
 941                         public MockResourceManager (string baseName, Assembly assembly)
 942                                 : base (baseName, assembly)
 943                         {
 944                         }
 945
 946                         public MockResourceManager (string baseName, Assembly assembly, Type usingResourceSet)
 947                                 : base (baseName, assembly, usingResourceSet)
 948                         {
 949                         }
 950
 951                         public new string BaseNameField {
 952                                 get { return base.BaseNameField; }
 953                         }
 954
 955                         public new Assembly MainAssembly {
 956                                 get { return base.MainAssembly; }
 957                         }
 958
 959                         public new Hashtable ResourceSets {
 960                                 get { return base.ResourceSets; }
 961                         }
 962
 963                         public new ResourceSet InternalGetResourceSet (CultureInfo culture, bool Createifnotexists, bool tryParents)
 964                         {
 965                                 return base.InternalGetResourceSet (culture,
 966                                         Createifnotexists, tryParents);
 967                         }
 968
 969                         public new string GetResourceFileName (CultureInfo culture)
 970                         {
 971                                 return base.GetResourceFileName (culture);
 972                         }
 973                 }
 974
 975                 class MockResourceSet : ResourceSet
 976                 {
 977                 }
 978         }
 979 }