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         [TestFixture]
  47         public class ResourceManagerTest
  48         {
  49                 private CultureInfo _orgUICulture;
  50
  51                 [SetUp]
  52                 public void SetUp ()
  53                 {
  54                         _orgUICulture = Thread.CurrentThread.CurrentUICulture;
  55                 }
  56
  57                 [TearDown]
  58                 public void TearDown ()
  59                 {
  60                         Thread.CurrentThread.CurrentUICulture = _orgUICulture;
  61                 }
  62
  63                 [Test] // ResourceManager ()
  64                 public void Constructor0 ()
  65                 {
  66                         MockResourceManager rm = new MockResourceManager ();
  67                         Assert.IsNull (rm.BaseName, "#1");
  68                         Assert.IsNull (rm.BaseNameField, "#2");
  69                         Assert.IsFalse (rm.IgnoreCase, "#3");
  70                         Assert.IsNull (rm.MainAssembly, "#4");
  71                         Assert.IsNull (rm.ResourceSets, "#5");
  72                         Assert.IsNotNull (rm.ResourceSetType, "#6");
  73                         Assert.IsTrue (typeof (ResourceSet).IsAssignableFrom (rm.ResourceSetType), "#7");
  74                         Assert.IsFalse (typeof (ResourceSet) == rm.ResourceSetType, "#8");
  75                 }
  76
  77                 [Test] // ResourceManager (Type)
  78                 public void Constructor1 ()
  79                 {
  80                         MockResourceManager rm = new MockResourceManager (typeof (string));
  81                         Assert.IsNotNull (rm.BaseName, "#1");
  82                         Assert.AreEqual ("String", rm.BaseName, "#2");
  83                         Assert.IsNotNull (rm.BaseNameField, "#3");
  84                         Assert.AreEqual ("String", rm.BaseNameField, "#4");
  85                         Assert.IsFalse (rm.IgnoreCase, "#5");
  86                         Assert.IsNotNull (rm.MainAssembly, "#6");
  87                         Assert.AreEqual (typeof (String).Assembly, rm.MainAssembly, "#7");
  88                         Assert.IsNotNull (rm.ResourceSets, "#8");
  89                         Assert.AreEqual (0, rm.ResourceSets.Count, "#9");
  90                         Assert.IsNotNull (rm.ResourceSetType, "#10");
  91                         Assert.IsTrue (typeof (ResourceSet).IsAssignableFrom (rm.ResourceSetType), "#11");
  92                         Assert.IsFalse (typeof (ResourceSet) == rm.ResourceSetType, "#12");
  93                         Assert.AreEqual ("RuntimeResourceSet", rm.ResourceSetType.Name, "#13");
  94                 }
  95
  96                 [Test] // ResourceManager (Type)
  97                 public void Constructor1_ResourceSource_Null ()
  98                 {
  99                         try {
 100                                 new ResourceManager ((Type) null);
 101                                 Assert.Fail ("#1");
 102                         } catch (ArgumentNullException ex) {
 103                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 104                                 Assert.IsNull (ex.InnerException, "#3");
 105                                 Assert.IsNotNull (ex.Message, "#4");
 106                                 Assert.IsNotNull (ex.ParamName, "#5");
 107                                 Assert.AreEqual ("resourceSource", ex.ParamName, "#6");
 108                         }
 109                 }
 110
 111                 [Test] // ResourceManager (String, Assembly)
 112                 public void Constructor2 ()
 113                 {
 114                         MockResourceManager rm = null;
 115                         Assembly assembly = null;
 116
 117                         assembly = Assembly.GetExecutingAssembly ();
 118                         rm = new MockResourceManager ("mono", assembly);
 119                         Assert.IsNotNull (rm.BaseName, "#A1");
 120                         Assert.AreEqual ("mono", rm.BaseName, "#A2");
 121                         Assert.IsNotNull (rm.BaseNameField, "#A3");
 122                         Assert.AreEqual ("mono", rm.BaseNameField, "#A4");
 123                         Assert.IsFalse (rm.IgnoreCase, "#A5");
 124                         Assert.IsNotNull (rm.MainAssembly, "#A6");
 125                         Assert.AreEqual (assembly, rm.MainAssembly, "#A7");
 126                         Assert.IsNotNull (rm.ResourceSets, "#A8");
 127                         Assert.AreEqual (0, rm.ResourceSets.Count, "#A9");
 128                         Assert.IsNotNull (rm.ResourceSetType, "#A10");
 129                         Assert.IsTrue (typeof (ResourceSet).IsAssignableFrom (rm.ResourceSetType), "#A11");
 130                         Assert.IsFalse (typeof (ResourceSet) == rm.ResourceSetType, "#A12");
 131                         Assert.AreEqual ("RuntimeResourceSet", rm.ResourceSetType.Name, "#A13");
 132
 133                         assembly = typeof (int).Assembly;
 134                         rm = new MockResourceManager (string.Empty, assembly);
 135                         Assert.IsNotNull (rm.BaseName, "#B1");
 136                         Assert.AreEqual (string.Empty, rm.BaseName, "#B2");
 137                         Assert.IsNotNull (rm.BaseNameField, "#B3");
 138                         Assert.AreEqual (string.Empty, rm.BaseNameField, "#B4");
 139                         Assert.IsFalse (rm.IgnoreCase, "#B5");
 140                         Assert.IsNotNull (rm.MainAssembly, "#B6");
 141                         Assert.AreEqual (assembly, rm.MainAssembly, "#B7");
 142                         Assert.IsNotNull (rm.ResourceSets, "#B8");
 143                         Assert.AreEqual (0, rm.ResourceSets.Count, "#B9");
 144                         Assert.IsNotNull (rm.ResourceSetType, "#B10");
 145                         Assert.IsTrue (typeof (ResourceSet).IsAssignableFrom (rm.ResourceSetType), "#B11");
 146                         Assert.IsFalse (typeof (ResourceSet) == rm.ResourceSetType, "#B12");
 147                         Assert.AreEqual ("RuntimeResourceSet", rm.ResourceSetType.Name, "#B13");
 148                 }
 149
 150                 [Test] // ResourceManager (String, Assembly)
 151                 public void Constructor2_BaseName_Null ()
 152                 {
 153                         try {
 154                                 new ResourceManager ((string) null, Assembly.
 155                                         GetExecutingAssembly ());
 156                                 Assert.Fail ("#1");
 157                         } catch (ArgumentNullException ex) {
 158                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 159                                 Assert.IsNull (ex.InnerException, "#3");
 160                                 Assert.IsNotNull (ex.Message, "#4");
 161                                 Assert.IsNotNull (ex.ParamName, "#5");
 162                                 Assert.AreEqual ("baseName", ex.ParamName, "#6");
 163                         }
 164                 }
 165
 166                 [Test] // ResourceManager (String, Assembly)
 167                 public void Constructor2_BaseName_Resources ()
 168                 {
 169                         MockResourceManager rm = new MockResourceManager (
 170                                 "mono.resources",
 171                                 Assembly.GetExecutingAssembly ());
 172                         Assert.IsNotNull (rm.BaseName, "#1");
 173                         Assert.AreEqual ("mono.resources", rm.BaseName, "#2");
 174                         Assert.IsNotNull (rm.BaseNameField, "#3");
 175                         Assert.AreEqual ("mono.resources", rm.BaseNameField, "#4");
 176                         Assert.IsFalse (rm.IgnoreCase, "#5");
 177                         Assert.IsNotNull (rm.MainAssembly, "#6");
 178                         Assert.AreEqual (Assembly.GetExecutingAssembly (), rm.MainAssembly, "#7");
 179                         Assert.IsNotNull (rm.ResourceSets, "#8");
 180                         Assert.AreEqual (0, rm.ResourceSets.Count, "#9");
 181                         Assert.IsNotNull (rm.ResourceSetType, "#10");
 182                         Assert.IsTrue (typeof (ResourceSet).IsAssignableFrom (rm.ResourceSetType), "#11");
 183                         Assert.IsFalse (typeof (ResourceSet) == rm.ResourceSetType, "#12");
 184                         Assert.AreEqual ("RuntimeResourceSet", rm.ResourceSetType.Name, "#13");
 185                 }
 186
 187                 [Test] // ResourceManager (String, Assembly)
 188                 public void Constructor2_Assembly_Null ()
 189                 {
 190                         try {
 191                                 new ResourceManager (string.Empty, (Assembly) null);
 192                                 Assert.Fail ("#1");
 193                         } catch (ArgumentNullException ex) {
 194                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 195                                 Assert.IsNull (ex.InnerException, "#3");
 196                                 Assert.IsNotNull (ex.Message, "#4");
 197                                 Assert.IsNotNull (ex.ParamName, "#5");
 198                                 Assert.AreEqual ("assembly", ex.ParamName, "#6");
 199                         }
 200                 }
 201
 202                 [Test] // ResourceManager (String, Assembly, Type)
 203                 public void Constructor3 ()
 204                 {
 205                         MockResourceManager rm = null;
 206                         Assembly assembly = null;
 207
 208                         assembly = Assembly.GetExecutingAssembly ();
 209                         rm = new MockResourceManager ("mono", assembly,
 210                                 typeof (ResourceSet));
 211                         Assert.IsNotNull (rm.BaseName, "#A1");
 212                         Assert.AreEqual ("mono", rm.BaseName, "#A2");
 213                         Assert.IsNotNull (rm.BaseNameField, "#A3");
 214                         Assert.AreEqual ("mono", rm.BaseNameField, "#A4");
 215                         Assert.IsFalse (rm.IgnoreCase, "#A5");
 216                         Assert.IsNotNull (rm.MainAssembly, "#A6");
 217                         Assert.AreEqual (assembly, rm.MainAssembly, "#A7");
 218                         Assert.IsNotNull (rm.ResourceSets, "#A8");
 219                         Assert.AreEqual (0, rm.ResourceSets.Count, "#A9");
 220                         Assert.IsNotNull (rm.ResourceSetType, "#A10");
 221                         Assert.AreEqual (typeof (ResourceSet), rm.ResourceSetType, "#A11");
 222
 223                         assembly = typeof (int).Assembly;
 224                         rm = new MockResourceManager ("mono", assembly,
 225                                 typeof (MockResourceSet));
 226                         Assert.IsNotNull (rm.BaseName, "#B1");
 227                         Assert.AreEqual ("mono", rm.BaseName, "#B2");
 228                         Assert.IsNotNull (rm.BaseNameField, "#B3");
 229                         Assert.AreEqual ("mono", rm.BaseNameField, "#B4");
 230                         Assert.IsFalse (rm.IgnoreCase, "#B5");
 231                         Assert.IsNotNull (rm.MainAssembly, "#B6");
 232                         Assert.AreEqual (assembly, rm.MainAssembly, "#B7");
 233                         Assert.IsNotNull (rm.ResourceSets, "#B8");
 234                         Assert.AreEqual (0, rm.ResourceSets.Count, "#B9");
 235                         Assert.IsNotNull (rm.ResourceSetType, "#B10");
 236                         Assert.AreEqual (typeof (MockResourceSet), rm.ResourceSetType, "#B11");
 237                 }
 238
 239                 [Test] // ResourceManager (String, Assembly, Type)
 240                 public void Constructor3_BaseName_Null ()
 241                 {
 242                         try {
 243                                 new ResourceManager ((string) null, Assembly.
 244                                         GetExecutingAssembly (),
 245                                         typeof (ResourceSet));
 246                                 Assert.Fail ("#1");
 247                         } catch (ArgumentNullException ex) {
 248                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 249                                 Assert.IsNull (ex.InnerException, "#3");
 250                                 Assert.IsNotNull (ex.Message, "#4");
 251                                 Assert.IsNotNull (ex.ParamName, "#5");
 252                                 Assert.AreEqual ("baseName", ex.ParamName, "#6");
 253                         }
 254                 }
 255
 256                 [Test] // ResourceManager (String, Assembly, Type)
 257                 public void Constructor3_BaseName_Resources ()
 258                 {
 259                         MockResourceManager rm = new MockResourceManager (
 260                                 "mono.resources",
 261                                 Assembly.GetExecutingAssembly (),
 262                                 typeof (ResourceSet));
 263                         Assert.IsNotNull (rm.BaseName, "#1");
 264                         Assert.AreEqual ("mono.resources", rm.BaseName, "#2");
 265                         Assert.IsNotNull (rm.BaseNameField, "#3");
 266                         Assert.AreEqual ("mono.resources", rm.BaseNameField, "#4");
 267                         Assert.IsFalse (rm.IgnoreCase, "#5");
 268                         Assert.IsNotNull (rm.MainAssembly, "#6");
 269                         Assert.AreEqual (Assembly.GetExecutingAssembly (), rm.MainAssembly, "#7");
 270                         Assert.IsNotNull (rm.ResourceSets, "#8");
 271                         Assert.AreEqual (0, rm.ResourceSets.Count, "#9");
 272                         Assert.IsNotNull (rm.ResourceSetType, "#10");
 273                         Assert.AreEqual (typeof (ResourceSet), rm.ResourceSetType, "#11");
 274                 }
 275
 276                 [Test] // ResourceManager (String, Assembly, Type)
 277                 public void Constructor3_Assembly_Null ()
 278                 {
 279                         try {
 280                                 new ResourceManager (string.Empty, (Assembly) null,
 281                                         typeof (ResourceSet));
 282                                 Assert.Fail ("#1");
 283                         } catch (ArgumentNullException ex) {
 284                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 285                                 Assert.IsNull (ex.InnerException, "#3");
 286                                 Assert.IsNotNull (ex.Message, "#4");
 287                                 Assert.IsNotNull (ex.ParamName, "#5");
 288                                 Assert.AreEqual ("assembly", ex.ParamName, "#6");
 289                         }
 290                 }
 291
 292                 [Test] // ResourceManager (String, Assembly, Type)
 293                 public void Constructor3_UsingResourceSet_Invalid ()
 294                 {
 295                         try {
 296                                 new ResourceManager ("mono", typeof (int).Assembly,
 297                                         typeof (string));
 298                                 Assert.Fail ("#1");
 299                         } catch (ArgumentException ex) {
 300                                 // Type parameter must refer to a subclass of
 301                                 // ResourceSet
 302                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 303                                 Assert.IsNull (ex.InnerException, "#3");
 304                                 Assert.IsNotNull (ex.Message, "#4");
 305                                 Assert.IsTrue (ex.Message.IndexOf ("ResourceSet") != -1, "#5");
 306                                 Assert.IsNotNull (ex.ParamName, "#6");
 307                                 Assert.AreEqual ("usingResourceSet", ex.ParamName, "#7");
 308                         }
 309                 }
 310
 311                 [Test] // ResourceManager (String, Assembly, Type)
 312                 public void Constructor3_UsingResourceSet_Null ()
 313                 {
 314                         MockResourceManager rm = new MockResourceManager (
 315                                 string.Empty, Assembly.GetExecutingAssembly (),
 316                                 (Type) null);
 317                         Assert.IsNotNull (rm.BaseName, "#1");
 318                         Assert.AreEqual (string.Empty, rm.BaseName, "#2");
 319                         Assert.IsNotNull (rm.BaseNameField, "#3");
 320                         Assert.AreEqual (string.Empty, rm.BaseNameField, "#4");
 321                         Assert.IsFalse (rm.IgnoreCase, "#5");
 322                         Assert.IsNotNull (rm.MainAssembly, "#6");
 323                         Assert.AreEqual (Assembly.GetExecutingAssembly (), rm.MainAssembly, "#7");
 324                         Assert.IsNotNull (rm.ResourceSets, "#8");
 325                         Assert.AreEqual (0, rm.ResourceSets.Count, "#9");
 326                         Assert.IsNotNull (rm.ResourceSetType, "#10");
 327                         Assert.IsTrue (typeof (ResourceSet).IsAssignableFrom (rm.ResourceSetType), "#11");
 328                         Assert.IsFalse (typeof (ResourceSet) == rm.ResourceSetType, "#12");
 329                         Assert.AreEqual ("RuntimeResourceSet", rm.ResourceSetType.Name, "#13");
 330                 }
 331
 332                 [Test]
 333                 public void CreateFileBasedResourceManager_BaseName_Null ()
 334                 {
 335                         try {
 336                                 ResourceManager.CreateFileBasedResourceManager (
 337                                         (string) null, AppDomain.CurrentDomain.BaseDirectory,
 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 ("baseName", ex.ParamName, "#6");
 346                         }
 347                 }
 348
 349                 [Test]
 350                 public void CreateFileBasedResourceManager_BaseName_Resources ()
 351                 {
 352                         ResourceManager rm = ResourceManager.CreateFileBasedResourceManager (
 353                                 "MyResources.resources", "Test/resources", null);
 354                         try {
 355                                 rm.GetResourceSet (CultureInfo.InvariantCulture, true, true);
 356                                 Assert.Fail ("#1");
 357                         } catch (MissingManifestResourceException ex) {
 358                                 // Could not find any resources appropriate for
 359                                 // the specified culture (or the neutral culture)
 360                                 //on disk
 361                                 Assert.AreEqual (typeof (MissingManifestResourceException), ex.GetType (), "#2");
 362                                 Assert.IsNull (ex.InnerException, "#3");
 363                                 Assert.IsNotNull (ex.Message, "#4");
 364                         }
 365                 }
 366
 367                 [Test]
 368                 public void CreateFileBasedResourceManager_ResourceDir_Null ()
 369                 {
 370                         try {
 371                                 ResourceManager.CreateFileBasedResourceManager (
 372                                         "whatever", (string) null,
 373                                         typeof (ResourceSet));
 374                                 Assert.Fail ("#1");
 375                         } catch (ArgumentNullException ex) {
 376                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 377                                 Assert.IsNull (ex.InnerException, "#3");
 378                                 Assert.IsNotNull (ex.Message, "#4");
 379                                 Assert.IsNotNull (ex.ParamName, "#5");
 380                                 Assert.AreEqual ("resourceDir", ex.ParamName, "#6");
 381                         }
 382                 }
 383
 384                 [Test]
 385                 public void CreateFileBasedResourceManager_UsingResourceSet_Invalid ()
 386                 {
 387                         ResourceManager rm = ResourceManager.CreateFileBasedResourceManager (
 388                                 "MyResources", "Test/resources", typeof (string));
 389                         Assert.IsNotNull (rm.BaseName, "#1");
 390                         Assert.AreEqual ("MyResources", rm.BaseName, "#2");
 391                         Assert.IsFalse (rm.IgnoreCase, "#3");
 392                         Assert.IsNotNull (rm.ResourceSetType, "#4");
 393                         Assert.AreEqual (typeof (string), rm.ResourceSetType, "#5");
 394                 }
 395
 396                 [Test]
 397                 public void CreateFileBasedResourceManager_UsingResourceSet_Null ()
 398                 {
 399                         ResourceManager rm = ResourceManager.CreateFileBasedResourceManager (
 400                                 "MyResources", "Test/resources", (Type) null);
 401                         Assert.IsNotNull (rm.BaseName, "#1");
 402                         Assert.AreEqual ("MyResources", rm.BaseName, "#2");
 403                         Assert.IsFalse (rm.IgnoreCase, "#3");
 404                         Assert.IsNotNull (rm.ResourceSetType, "#4");
 405                         Assert.IsTrue (typeof (ResourceSet).IsAssignableFrom (rm.ResourceSetType), "#5");
 406                         Assert.IsFalse (typeof (ResourceSet) == rm.ResourceSetType, "#6");
 407                         Assert.AreEqual ("RuntimeResourceSet", rm.ResourceSetType.Name, "#7");
 408                 }
 409
 410                 [Test]
 411                 [Category ("MobileNotWorking")]
 412                 public void GetObject ()
 413                 {
 414                         ResourceManager rm = ResourceManager.
 415                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 416
 417                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 418                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld"), "#A1");
 419                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", new CultureInfo ("de")), "#A2");
 420                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", (CultureInfo) null), "#A3");
 421                         Assert.IsNull (rm.GetObject ("deHelloWorld"), "#A4");
 422                         Assert.AreEqual ("Hallo Welt", rm.GetObject ("deHelloWorld", new CultureInfo ("de")), "#A5");
 423                         Assert.IsNull (rm.GetObject ("deHelloWorld", (CultureInfo) null), "#A6");
 424
 425                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("de");
 426                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld"), "#B1");
 427                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", (CultureInfo) null), "#B2");
 428                         Assert.AreEqual ("Hallo Welt", rm.GetObject ("deHelloWorld"), "#B3");
 429                         Assert.IsNull (rm.GetObject ("deHelloWorld", new CultureInfo ("nl-BE")), "#B4");
 430                         Assert.AreEqual ("Hallo Welt", rm.GetObject ("deHelloWorld", (CultureInfo) null), "#B5");
 431
 432                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("nl-BE");
 433                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld"), "#C1");
 434                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", new CultureInfo ("de")), "#C2");
 435                         Assert.AreEqual ("Hello World", rm.GetObject ("HelloWorld", (CultureInfo) null), "#C3");
 436                         Assert.IsNull (rm.GetObject ("deHelloWorld"), "#C4");
 437                         Assert.AreEqual ("Hallo Welt", rm.GetObject ("deHelloWorld", new CultureInfo ("de")), "#C5");
 438                         Assert.IsNull (rm.GetObject ("deHelloWorld", (CultureInfo) null), "#C6");
 439
 440                         rm.ReleaseAllResources ();
 441                 }
 442
 443                 [Test]
 444                 public void GetObject_Name_Null ()
 445                 {
 446                         ResourceManager rm = new ResourceManager (typeof (string));
 447                         try {
 448                                 rm.GetObject ((string) null);
 449                                 Assert.Fail ("#A1");
 450                         } catch (ArgumentNullException ex) {
 451                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 452                                 Assert.IsNull (ex.InnerException, "#A3");
 453                                 Assert.IsNotNull (ex.Message, "#A4");
 454                                 Assert.IsNotNull (ex.ParamName, "#A5");
 455                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 456                         }
 457
 458                         try {
 459                                 rm.GetObject ((string) null, CultureInfo.InvariantCulture);
 460                                 Assert.Fail ("#B1");
 461                         } catch (ArgumentNullException ex) {
 462                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 463                                 Assert.IsNull (ex.InnerException, "#B3");
 464                                 Assert.IsNotNull (ex.Message, "#B4");
 465                                 Assert.IsNotNull (ex.ParamName, "#B5");
 466                                 Assert.AreEqual ("name", ex.ParamName, "#B6");
 467                         }
 468                         rm.ReleaseAllResources ();
 469                 }
 470
 471                 [Test]
 472                 [Category ("MobileNotWorking")]
 473                 public void GetObject_ResourceSet_Disposed ()
 474                 {
 475                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("de");
 476                         ResourceManager rm = ResourceManager.
 477                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 478                         ResourceSet rs = rm.GetResourceSet (new CultureInfo ("de"),
 479                                 true, true);
 480                         rs.Dispose ();
 481
 482                         try {
 483                                 rm.GetObject ("deHelloWorld");
 484                                 Assert.Fail ("#1");
 485                         } catch (ObjectDisposedException ex) {
 486                                 // Cannot access a closed resource set
 487                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 488                                 Assert.IsNull (ex.InnerException, "#3");
 489                                 Assert.IsNotNull (ex.Message, "#4");
 490                         } finally {
 491                                 rm.ReleaseAllResources ();
 492                         }
 493                 }
 494
 495                 [Test]
 496                 public void GetResourceFileName ()
 497                 {
 498                         MockResourceManager rm = new MockResourceManager ();
 499                         Assert.AreEqual (".nl-BE.resources",
 500                                 rm.GetResourceFileName (new CultureInfo ("nl-BE")), "#A1");
 501                         Assert.AreEqual (".fr.resources",
 502                                 rm.GetResourceFileName (new CultureInfo ("fr")), "#A2");
 503                         Assert.AreEqual (".resources",
 504                                 rm.GetResourceFileName (CultureInfo.InvariantCulture), "#A3");
 505
 506                         rm = new MockResourceManager (typeof (string));
 507                         Assert.AreEqual ("String.nl-BE.resources",
 508                                 rm.GetResourceFileName (new CultureInfo ("nl-BE")), "#B1");
 509                         Assert.AreEqual ("String.fr.resources",
 510                                 rm.GetResourceFileName (new CultureInfo ("fr")), "#B2");
 511                         Assert.AreEqual ("String.resources",
 512                                 rm.GetResourceFileName (CultureInfo.InvariantCulture), "#B3");
 513                 }
 514
 515                 [Test]
 516                 public void GetResourceFileName_Culture_Null ()
 517                 {
 518                         MockResourceManager rm = new MockResourceManager ();
 519                         try {
 520                                 rm.GetResourceFileName ((CultureInfo) null);
 521                                 Assert.Fail ("#1");
 522                         } catch (NullReferenceException) {
 523                         }
 524                 }
 525
 526                 [Test]
 527                 public void GetResourceSet_Culture_Null ()
 528                 {
 529                         ResourceManager rm = new ResourceManager (typeof (string));
 530                         try {
 531                                 rm.GetResourceSet ((CultureInfo) null, false, false);
 532                                 Assert.Fail ("#1");
 533                         } catch (ArgumentNullException ex) {
 534                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 535                                 Assert.IsNull (ex.InnerException, "#3");
 536                                 Assert.IsNotNull (ex.Message, "#4");
 537                                 Assert.IsNotNull (ex.ParamName, "#5");
 538                                 Assert.AreEqual ("culture", ex.ParamName, "#6");
 539                         }
 540                         rm.ReleaseAllResources ();
 541                 }
 542
 543                 [Test]
 544                 [Category ("MobileNotWorking")]
 545                 public void GetString ()
 546                 {
 547                         ResourceManager rm = ResourceManager.
 548                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 549
 550                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 551                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld"), "#A1");
 552                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", new CultureInfo ("de")), "#A2");
 553                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", (CultureInfo) null), "#A3");
 554                         Assert.IsNull (rm.GetString ("deHelloWorld"), "#A4");
 555                         Assert.AreEqual ("Hallo Welt", rm.GetString ("deHelloWorld", new CultureInfo ("de")), "#A5");
 556                         Assert.IsNull (rm.GetString ("deHelloWorld", (CultureInfo) null), "#A6");
 557
 558                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("de");
 559                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld"), "#B1");
 560                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", (CultureInfo) null), "#B2");
 561                         Assert.AreEqual ("Hallo Welt", rm.GetString ("deHelloWorld"), "#B3");
 562                         Assert.IsNull (rm.GetString ("deHelloWorld", new CultureInfo ("nl-BE")), "#B4");
 563                         Assert.AreEqual ("Hallo Welt", rm.GetString ("deHelloWorld", (CultureInfo) null), "#B5");
 564
 565                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("nl-BE");
 566                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld"), "#C1");
 567                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", new CultureInfo ("de")), "#C2");
 568                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld", (CultureInfo) null), "#C3");
 569                         Assert.IsNull (rm.GetString ("deHelloWorld"), "#C4");
 570                         Assert.AreEqual ("Hallo Welt", rm.GetString ("deHelloWorld", new CultureInfo ("de")), "#C5");
 571                         Assert.IsNull (rm.GetString ("deHelloWorld", (CultureInfo) null), "#C6");
 572
 573                         rm.ReleaseAllResources ();
 574                 }
 575
 576                 [Test]
 577                 public void GetString_Name_Null ()
 578                 {
 579                         ResourceManager rm = new ResourceManager (typeof (string));
 580                         try {
 581                                 rm.GetString ((string) null);
 582                                 Assert.Fail ("#A1");
 583                         } catch (ArgumentNullException ex) {
 584                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 585                                 Assert.IsNull (ex.InnerException, "#A3");
 586                                 Assert.IsNotNull (ex.Message, "#A4");
 587                                 Assert.IsNotNull (ex.ParamName, "#A5");
 588                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 589                         }
 590
 591                         try {
 592                                 rm.GetString ((string) null, CultureInfo.InvariantCulture);
 593                                 Assert.Fail ("#B1");
 594                         } catch (ArgumentNullException ex) {
 595                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 596                                 Assert.IsNull (ex.InnerException, "#B3");
 597                                 Assert.IsNotNull (ex.Message, "#B4");
 598                                 Assert.IsNotNull (ex.ParamName, "#B5");
 599                                 Assert.AreEqual ("name", ex.ParamName, "#B6");
 600                         }
 601                         rm.ReleaseAllResources ();
 602                 }
 603
 604                 [Test]
 605                 [Category ("MobileNotWorking")]
 606                 [SetCulture ("de")]
 607                 public void GetString_ResourceSet_Disposed ()
 608                 {
 609                         ResourceManager rm = ResourceManager.
 610                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 611                         ResourceSet rs = rm.GetResourceSet (new CultureInfo ("de"),
 612                                 true, true);
 613                         rs.Dispose ();
 614
 615                         Assert.IsNull (rm.GetString ("deHelloWorld"));
 616                         rm.ReleaseAllResources ();
 617                 }
 618
 619                 [Test]
 620                 [Category ("MobileNotWorking")]
 621                 public void GetStream ()
 622                 {
 623                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 624                         ResourceManager rm = ResourceManager.
 625                                 CreateFileBasedResourceManager ("StreamTest", "Test/resources", null);
 626                         UnmanagedMemoryStream s = rm.GetStream ("test");
 627                         Assert.AreEqual (22, s.Length, "#A1");
 628                         Assert.AreEqual ("veritas vos liberabit\n", new StreamReader (s).ReadToEnd (), "#A2");
 629                         s.Close ();
 630
 631                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("ja-JP");
 632                         s = rm.GetStream ("test");
 633                         Assert.AreEqual (22, s.Length, "#B1");
 634                         Assert.AreEqual ("Veritas Vos Liberabit\n", new StreamReader (s).ReadToEnd (), "#B2");
 635                         s.Close ();
 636
 637                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("nl-BE");
 638                         s = rm.GetStream ("test");
 639                         Assert.AreEqual (22, s.Length, "#C1");
 640                         Assert.AreEqual ("veritas vos liberabit\n", new StreamReader (s).ReadToEnd (), "#C2");
 641                         rm.ReleaseAllResources ();
 642                 }
 643
 644                 [Test]
 645                 [Category ("MobileNotWorking")]
 646                 public void GetStream_Culture ()
 647                 {
 648                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 649                         ResourceManager rm = ResourceManager.
 650                                 CreateFileBasedResourceManager ("StreamTest", "Test/resources", null);
 651                         UnmanagedMemoryStream s = rm.GetStream ("test", new CultureInfo ("ja-JP"));
 652                         Assert.AreEqual (22, s.Length, "#1");
 653                         Assert.AreEqual ("Veritas Vos Liberabit\n", new StreamReader (s).ReadToEnd (), "#2");
 654                         s.Close ();
 655
 656                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 657                         s = rm.GetStream ("test", null);
 658                         Assert.AreEqual (22, s.Length, "#1");
 659                         Assert.AreEqual ("veritas vos liberabit\n", new StreamReader (s).ReadToEnd (), "#2");
 660                         s.Close ();
 661
 662                         Thread.CurrentThread.CurrentUICulture = new CultureInfo ("ja-JP");
 663                         s = rm.GetStream ("test", null);
 664                         Assert.AreEqual (22, s.Length, "#1");
 665                         Assert.AreEqual ("Veritas Vos Liberabit\n", new StreamReader (s).ReadToEnd (), "#2");
 666                         s.Close ();
 667                         rm.ReleaseAllResources ();
 668                 }
 669
 670                 [Test]
 671                 public void GetStream_Name_Null ()
 672                 {
 673                         ResourceManager rm = new ResourceManager (typeof (string));
 674                         try {
 675                                 rm.GetStream ((string) null);
 676                                 Assert.Fail ("#A1");
 677                         } catch (ArgumentNullException ex) {
 678                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 679                                 Assert.IsNull (ex.InnerException, "#A3");
 680                                 Assert.IsNotNull (ex.Message, "#A4");
 681                                 Assert.IsNotNull (ex.ParamName, "#A5");
 682                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 683                         }
 684
 685                         try {
 686                                 rm.GetStream ((string) null, CultureInfo.InvariantCulture);
 687                                 Assert.Fail ("#A1");
 688                         } catch (ArgumentNullException ex) {
 689                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 690                                 Assert.IsNull (ex.InnerException, "#A3");
 691                                 Assert.IsNotNull (ex.Message, "#A4");
 692                                 Assert.IsNotNull (ex.ParamName, "#A5");
 693                                 Assert.AreEqual ("name", ex.ParamName, "#A6");
 694                         }
 695                         rm.ReleaseAllResources ();
 696                 }
 697
 698                 [Test]
 699                 [Category ("MobileNotWorking")]
 700                 public void GetStream_Resource_DoesNotExist ()
 701                 {
 702                         ResourceManager rm = ResourceManager.
 703                                 CreateFileBasedResourceManager ("StreamTest", "Test/resources", null);
 704                         Assert.IsNull (rm.GetStream ("HelloWorld"));
 705                         rm.ReleaseAllResources ();
 706                 }
 707
 708                 [Test]
 709                 [Category ("MobileNotWorking")]
 710                 public void GetStream_Resource_NonStream ()
 711                 {
 712                         ResourceManager rm = ResourceManager.
 713                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 714
 715                         try {
 716                                 rm.GetStream ("HelloWorld", CultureInfo.InvariantCulture);
 717                                 Assert.Fail ("#1");
 718                         } catch (InvalidOperationException ex) {
 719                                 // Resource 'HelloWorld' was not a Stream - call
 720                                 // GetObject instead
 721                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 722                                 Assert.IsNull (ex.InnerException, "#3");
 723                                 Assert.IsNotNull (ex.Message, "#4");
 724                         } finally {
 725                                 rm.ReleaseAllResources ();
 726                         }
 727                 }
 728
 729                 [Test]
 730                 public void GetStream_ResourceFile_DoesNotExist ()
 731                 {
 732                         ResourceManager rm = ResourceManager.
 733                                 CreateFileBasedResourceManager ("DoesNotExist", "Test/resources", null);
 734                         try {
 735                                 rm.GetStream ("HelloWorld");
 736                                 Assert.Fail ("#1");
 737                         } catch (MissingManifestResourceException ex) {
 738                                 // Could not find any resources appropriate for
 739                                 // the specified culture (or the neutral culture)
 740                                 //on disk
 741                                 Assert.AreEqual (typeof (MissingManifestResourceException), ex.GetType (), "#2");
 742                                 Assert.IsNull (ex.InnerException, "#3");
 743                                 Assert.IsNotNull (ex.Message, "#4");
 744                         }
 745                 }
 746
 747                 [Test]
 748                 [Category ("MobileNotWorking")]
 749                 public void GetStream_ResourceSet_Disposed ()
 750                 {
 751                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 752                         ResourceManager rm = ResourceManager.
 753                                 CreateFileBasedResourceManager ("StreamTest", "Test/resources", null);
 754                         ResourceSet rs = rm.GetResourceSet (new CultureInfo ("ja-JP"),
 755                                 true, true);
 756                         rs.Dispose ();
 757
 758                         try {
 759                                 rm.GetStream ("test", new CultureInfo ("ja-JP"));
 760                                 Assert.Fail ("#1");
 761                         } catch (ObjectDisposedException ex) {
 762                                 // Cannot access a closed resource set
 763                                 Assert.AreEqual (typeof (ObjectDisposedException), ex.GetType (), "#2");
 764                                 Assert.IsNull (ex.InnerException, "#3");
 765                                 Assert.IsNotNull (ex.Message, "#4");
 766                         } finally {
 767                                 rm.ReleaseAllResources ();
 768                         }
 769                 }
 770
 771                 [Test]
 772                 [Category ("MobileNotWorking")]
 773                 public void IgnoreCase ()
 774                 {
 775                         ResourceManager rm = ResourceManager.
 776                                 CreateFileBasedResourceManager ("MyResources", "Test/resources", null);
 777
 778                         Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
 779                         Assert.IsFalse (rm.IgnoreCase, "#A1");
 780                         Assert.IsNull (rm.GetString ("helloWORLD"), "#A2");
 781                         rm.IgnoreCase = true;
 782                         Assert.IsTrue (rm.IgnoreCase, "#B1");
 783                         Assert.AreEqual ("Hello World", rm.GetString ("HelloWorld"), "#B2");
 784                         rm.ReleaseAllResources ();
 785                 }
 786
 787                 [Test]
 788                 public void TestSatellites ()
 789                 {
 790                         ResourceManager manager = new ResourceManager("Resources", GetType ().Assembly);
 791
 792                         Assert.AreEqual ("Hei", manager.GetString ("Hello", new CultureInfo ("nn-NO")), "nn-NO");
 793                         Assert.AreEqual ("Hola", manager.GetString ("Hello", new CultureInfo ("es-ES")), "es-ES");
 794                         Assert.AreEqual ("Hello", manager.GetString ("Hello", new CultureInfo ("en-US")), "en-US");
 795                 }
 796
 797                 class MockResourceManager : ResourceManager
 798                 {
 799                         public MockResourceManager ()
 800                         {
 801                         }
 802
 803                         public MockResourceManager (Type resourceSource) : base (resourceSource)
 804                         {
 805                         }
 806
 807                         public MockResourceManager (string baseName, Assembly assembly)
 808                                 : base (baseName, assembly)
 809                         {
 810                         }
 811
 812                         public MockResourceManager (string baseName, Assembly assembly, Type usingResourceSet)
 813                                 : base (baseName, assembly, usingResourceSet)
 814                         {
 815                         }
 816
 817                         public new string BaseNameField {
 818                                 get { return base.BaseNameField; }
 819                         }
 820
 821                         public new Assembly MainAssembly {
 822                                 get { return base.MainAssembly; }
 823                         }
 824
 825                         public new Hashtable ResourceSets {
 826                                 get { return base.ResourceSets; }
 827                         }
 828
 829                         public new ResourceSet InternalGetResourceSet (CultureInfo culture, bool Createifnotexists, bool tryParents)
 830                         {
 831                                 return base.InternalGetResourceSet (culture,
 832                                         Createifnotexists, tryParents);
 833                         }
 834
 835                         public new string GetResourceFileName (CultureInfo culture)
 836                         {
 837                                 return base.GetResourceFileName (culture);
 838                         }
 839                 }
 840
 841                 class MockResourceSet : ResourceSet
 842                 {
 843                 }
 844         }
 845 }